Benutzer und Gruppen in Red Hat Enterprise Linux verwalten

Einführung

In diesem Lab erwerben Sie grundlegende Fähigkeiten im Management lokaler Benutzer und Gruppen innerhalb einer Red Hat Enterprise Linux (RHEL)-Umgebung. Sie beginnen mit dem Verständnis grundlegender Benutzer- und Gruppenkonzepte, einschließlich der Identifizierung von Benutzer- und Gruppeninformationen sowie der Dateieigentümerschaft.

Anschließend lernen Sie, wie Sie Superuser-Zugriff erhalten, lokale Benutzerkonten erstellen und modifizieren, lokale Gruppenkonten verwalten und Benutzer-Passwortrichtlinien konfigurieren. Diese praktische Erfahrung vermittelt Ihnen das Wissen, um den Zugriff und die Berechtigungen auf Ihrem Linux-System effektiv zu steuern.

Dies ist ein Guided Lab, das schrittweise Anweisungen bietet, um Ihnen beim Lernen und Üben zu helfen. Befolgen Sie die Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Labor der Stufe Anfänger mit einer Abschlussquote von 84% ist. Es hat eine positive Bewertungsrate von 100% von den Lernenden erhalten.

Benutzer- und Gruppenkonzepte verstehen

In diesem Schritt lernen Sie grundlegende Benutzer- und Gruppenkonzepte in Red Hat Enterprise Linux (RHEL) kennen und wie Sie verschiedene Befehle verwenden, um Benutzer- und Gruppeninformationen zu untersuchen. Das Verständnis dieser Konzepte ist entscheidend für die Verwaltung von Berechtigungen und die Zugriffskontrolle auf einem Linux-System.

Jede Datei und jeder Prozess auf einem Linux-System ist einem Benutzer und einer Gruppe zugeordnet. Diese Zuordnung bestimmt, wer Dateien lesen, schreiben oder ausführen kann und wer Prozesse verwalten kann.

Zuerst wollen wir untersuchen, wie man den aktuellen Benutzer und andere Benutzer auf dem System mit dem Befehl id identifiziert.

Verwenden Sie den Befehl id, um Informationen über den aktuell angemeldeten Benutzer anzuzeigen. Dieser Befehl zeigt die Benutzer-ID (UID), die primäre Gruppen-ID (GID) und alle Gruppen an, zu denen der Benutzer gehört.
```
id
```
Sie sollten eine Ausgabe ähnlich dieser sehen, die Ihre labex-Benutzerinformationen anzeigt:
```
uid=1000(labex) gid=1000(labex) groups=1000(labex),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```
Um grundlegende Informationen über einen anderen Benutzer, wie z. B. den root-Benutzer, anzuzeigen, übergeben Sie den Benutzernamen als Argument an den Befehl id.
```
id root
```
Die Ausgabe zeigt die UID (0), GID (0) und Gruppen des root-Benutzers an:
```
uid=0(root) gid=0(root) groups=0(root) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```

Als Nächstes lernen Sie, wie Sie den Eigentümer von Dateien und Verzeichnissen mit dem Befehl ls identifizieren.

Verwenden Sie den Befehl ls -l, um den Eigentümer einer Datei anzuzeigen. Erstellen Sie zuerst eine Dummy-Datei in Ihrem Verzeichnis ~/project.
```
touch ~/project/mytextfile.txt
ls -l ~/project/mytextfile.txt
```
Die Ausgabe zeigt labex sowohl als Benutzer- als auch als Gruppeneigentümer von mytextfile.txt an:
```
-rw-r--r-- 1 labex labex 0 Feb  5 11:10 /home/labex/project/mytextfile.txt
```
Verwenden Sie den Befehl ls -ld, um den Eigentümer eines Verzeichnisses anzuzeigen, anstatt den Inhalt dieses Verzeichnisses. In der folgenden Ausgabe zeigt die dritte Spalte den Benutzernamen und die vierte Spalte den Gruppennamen.
```
ls -ld ~/project
```
Sie sehen labex als Eigentümer Ihres Verzeichnisses ~/project:
```
drwxr-xr-x 2 labex labex 6 Feb  5 11:10 /home/labex/project
```

Nun wollen wir untersuchen, wie man Prozessinformationen und den jedem Prozess zugeordneten Benutzer mit dem Befehl ps anzeigt.

Verwenden Sie den Befehl ps -au, um Prozesse anzuzeigen. Die Option a zeigt alle Prozesse mit einem Terminal an, und die Option u zeigt den Benutzer an, der einem Prozess zugeordnet ist. In der folgenden Ausgabe zeigt die erste Spalte den Benutzernamen an.

ps -au

Sie sehen verschiedene Prozesse, wobei labex und root als häufige Benutzer auftreten:

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0  10608  3808 ?        Ss   00:00   0:00 /sbin/init
root        42  0.0  0.0  10608  3808 ?        Ss   00:00   0:00 /sbin/init
labex      123  0.0  0.1 224152  5756 pts/0    Ss   00:00   0:00 -bash
labex      150  0.0  0.0 225556  3652 pts/0    R+   00:00   0:00 ps -au

Schließlich werden Sie die Dateien /etc/passwd und /etc/group untersuchen, in denen Benutzer- bzw. Gruppeninformationen gespeichert sind. Diese Dateien sind entscheidend für das Verständnis, wie Benutzer- und Gruppenkonten auf einem Linux-System definiert sind.

Jede Zeile in der Datei /etc/passwd enthält Informationen über einen Benutzer. Die Datei ist in sieben durch Doppelpunkte getrennte Felder unterteilt. Verwenden Sie cat, um ihren Inhalt anzuzeigen.
```
cat /etc/passwd
```
Suchen Sie den Eintrag für labex und root. Für labex sollte er so ähnlich aussehen:
```
labex:x:1000:1000:LabEx User:/home/labex:/bin/bash
```
Lassen Sie uns jedes Feld aufschlüsseln:
- labex: Der Benutzername für diesen Benutzer.
- x: Das verschlüsselte Passwort des Benutzers wurde historisch hier gespeichert; dies ist jetzt ein Platzhalter, da Passwörter aus Sicherheitsgründen in /etc/shadow gespeichert werden.
- 1000: Die UID-Nummer für dieses Benutzerkonto.
- 1000: Die GID-Nummer für die primäre Gruppe dieses Benutzerkontos.
- LabEx User: Ein kurzer Kommentar, eine Beschreibung oder der echte Name für diesen Benutzer.
- /home/labex: Das Home-Verzeichnis des Benutzers und das anfängliche Arbeitsverzeichnis, wenn die Login-Shell startet.
- /bin/bash: Das Standard-Shell-Programm für diesen Benutzer, das beim Login ausgeführt wird.
Jede Zeile in der Datei /etc/group enthält Informationen über eine Gruppe. Jeder Gruppeneintrag ist in vier durch Doppelpunkte getrennte Felder unterteilt. Verwenden Sie cat, um ihren Inhalt anzuzeigen.
```
cat /etc/group
```
Sie sehen Einträge für verschiedene Systemgruppen und benutzerprivate Gruppen. Zum Beispiel könnte der labex-Gruppeneintrag so aussehen:
```
labex:x:1000:
```
Lassen Sie uns jedes Feld aufschlüsseln:
- labex: Name für diese Gruppe.
- x: Veraltetes Gruppenpasswortfeld; dies ist jetzt ein Platzhalter.
- 1000: Die GID-Nummer für diese Gruppe.
- (leer): Eine Liste der Benutzer, die Mitglieder dieser Gruppe als sekundäre Gruppe sind. Wenn dieses Feld leer ist, bedeutet dies, dass keine zusätzlichen Benutzer explizit als sekundäre Mitglieder dieser Gruppe aufgeführt sind (obwohl der primäre Benutzer labex implizit ein Mitglied ist).
Primäre Gruppen und sekundäre Gruppen:
Jeder Benutzer hat genau eine primäre Gruppe. Für lokale Benutzer wird diese Gruppe durch GID in der Datei /etc/passwd aufgeführt. Die primäre Gruppe besitzt Dateien, die der Benutzer erstellt. Beim Erstellen eines regulären Benutzers wird oft eine Gruppe mit demselben Namen wie der Benutzer erstellt, um die primäre Gruppe für den Benutzer zu sein. Der Benutzer ist typischerweise das einzige Mitglied dieser User Private Group. Dieses Design vereinfacht die Dateiberechtigungsverwaltung.

Benutzer können auch sekundäre Gruppen haben. Die Mitgliedschaft in sekundären Gruppen wird in der Datei /etc/group gespeichert. Benutzern wird der Zugriff auf Dateien gewährt, basierend darauf, ob eine ihrer Gruppen Zugriff hat, unabhängig davon, ob die Gruppen primär oder sekundär sind. Wenn der Benutzer labex beispielsweise eine primäre Gruppe labex und wheel als sekundäre Gruppe hat, kann dieser Benutzer Dateien lesen, die eine dieser beiden Gruppen lesen kann.

Der Befehl id kann alle Gruppenmitgliedschaften für einen Benutzer anzeigen. Rufen Sie die Ausgabe von id für labex auf:
```
uid=1000(labex) gid=1000(labex) groups=1000(labex),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```
Hier zeigt gid=1000(labex) an, dass labex die primäre Gruppe ist. groups=1000(labex),10(wheel) listet alle Gruppenmitgliedschaften auf und zeigt labex als primäre Gruppe und wheel als sekundäre Gruppe.

Superuser-Zugriff erlangen

In diesem Schritt lernen Sie, wie Sie Superuser-Zugriff (Root-Rechte) auf einem RHEL-System erhalten. Der Superuser-Zugriff ist unerlässlich für die Durchführung administrativer Aufgaben wie die Installation von Software, die Verwaltung von Benutzern und die Konfiguration von Systemeinstellungen. Sie werden die Befehle su und sudo untersuchen, die die primären Werkzeuge für die Privilegienausweitung sind.

Der Befehl su (Substitute User) ermöglicht es Ihnen, zu einem anderen Benutzerkonto zu wechseln. Wenn er ohne Benutzernamen verwendet wird, wird standardmäßig der Benutzer root verwendet.

Verwenden Sie den Befehl su -, um zum Benutzer root zu wechseln. Die Option Bindestrich (-) stellt sicher, dass Sie eine Login-Shell erhalten, was bedeutet, dass die Umgebungsvariablen und der Pfad des Benutzers root geladen werden. Sie werden nach dem root-Passwort gefragt, das redhat lautet.
```
su -
```
Nach der Eingabe des Passworts redhat ändert sich Ihre Eingabeaufforderung zu [root@host ~]#, was anzeigt, dass Sie jetzt der Benutzer root sind.
```
Password:
[root@host ~]#
```
Um zu überprüfen, ob Sie root sind, können Sie den Befehl whoami ausführen:
```
whoami
```
Die Ausgabe sollte sein:
```
root
```
Um die root-Shell zu verlassen und zu Ihrem labex-Benutzer zurückzukehren, geben Sie exit ein.
```
exit
```
Ihre Eingabeaufforderung kehrt zu [labex@host ~]$ zurück.

Der Befehl sudo (superuser do) ermöglicht es einem berechtigten Benutzer, einen Befehl als Superuser oder einen anderen Benutzer auszuführen, wie in der Datei sudoers angegeben. Der Benutzer labex ist so konfiguriert, dass er sudo-Rechte hat, ohne ein Passwort zu benötigen, was in vielen Cloud- und Lab-Umgebungen üblich ist.

Verwenden Sie den Befehl sudo -i, um zum root-Konto zu wechseln. Dieser Befehl wird im Allgemeinen gegenüber su - bevorzugt, da er eine sicherere Möglichkeit bietet, Befehle mit erhöhten Rechten auszuführen. Wenn Sie sudo -i verwenden, verwenden Sie weiterhin Ihr eigenes Benutzerkonto, jedoch mit Root-Rechten, und Befehle werden in Ihrem Konto protokolliert, wodurch es einfacher wird, zu verfolgen, was getan wurde.
```
sudo -i
```
Ihre Eingabeaufforderung ändert sich zu [root@host ~]#, was anzeigt, dass Sie jetzt der Benutzer root sind.
```
[root@host ~]#
```
Auch hier können Sie mit whoami überprüfen:
```
whoami
```
Die Ausgabe sollte sein:
```
root
```
Um die root-Shell zu verlassen und zu Ihrem labex-Benutzer zurückzukehren, geben Sie exit ein.
```
exit
```
Ihre Eingabeaufforderung kehrt zu [labex@host ~]$ zurück.
Sie können sudo auch verwenden, um einen einzelnen Befehl mit Root-Rechten auszuführen, ohne zur root-Shell zu wechseln. Um beispielsweise den Inhalt von /etc/shadow anzuzeigen (der nur von root gelesen werden kann), können Sie sudo cat /etc/shadow verwenden.
```
sudo cat /etc/shadow | head -n 3
```
Dadurch werden die ersten drei Zeilen der Datei /etc/shadow angezeigt, was zeigt, dass der Befehl cat mit Root-Rechten ausgeführt wurde.
```
root:*:19780:0:99999:7:::
bin:*:19780:0:99999:7:::
daemon:*:19780:0:99999:7:::
```
Die Datei /etc/sudoers ist die Hauptkonfigurationsdatei für den Befehl sudo. Sie definiert, welche Benutzer oder Gruppen welche Befehle mit erhöhten Rechten ausführen können. Um Probleme zu vermeiden, wenn mehrere Administratoren versuchen, die Datei gleichzeitig zu bearbeiten, sollten Sie sie nur mit dem speziellen Befehl visudo bearbeiten. Der Editor visudo validiert die Datei auch, um Syntaxfehler zu vermeiden.

Ein häufiger Eintrag in /etc/sudoers erlaubt Mitgliedern der Gruppe wheel, jeden Befehl als root auszuführen. Der Benutzer labex ist Mitglied der Gruppe wheel, weshalb sudo ohne Passwort funktioniert.
```
sudo grep wheel /etc/sudoers
```
Sie sollten eine Zeile ähnlich dieser sehen, die der Gruppe wheel sudo-Zugriff gewährt:
```
%wheel        ALL=(ALL:ALL)       ALL
```
Diese Zeile bedeutet:
- %wheel: Die Regel gilt für Mitglieder der Gruppe wheel. Das Symbol % bezeichnet eine Gruppe.
- ALL=(ALL:ALL): Auf jedem Host (erstes ALL) können Benutzer in der Gruppe wheel Befehle als jeder Benutzer (zweites ALL) und jede Gruppe (drittes ALL) ausführen.
- ALL: Benutzer in der Gruppe wheel können jeden Befehl ausführen.

Dies schließt Ihre Erkundung des Erhalts von Superuser-Zugriff ab. Sie verstehen jetzt den Unterschied zwischen su - und sudo -i und wie Sie Befehle mit erhöhten Rechten ausführen.

Lokale Benutzerkonten erstellen und ändern

In diesem Schritt lernen Sie, wie Sie lokale Benutzerkonten auf einem RHEL-System erstellen, ändern und löschen. Die Verwaltung von Benutzerkonten ist eine grundlegende administrative Aufgabe, die sicherstellt, dass jeder Benutzer angemessenen Zugriff und Berechtigungen hat. Sie verwenden Befehle wie useradd, usermod, userdel und passwd.

Zuerst erstellen wir ein neues Benutzerkonto.

Verwenden Sie den Befehl useradd, um einen neuen Benutzer zu erstellen. Standardmäßig erstellt useradd einen neuen Benutzer mit einer UID größer oder gleich 1000, erstellt ein Home-Verzeichnis (/home/username) und setzt die Standard-Shell auf /bin/bash. Sie benötigen sudo-Rechte, um diesen Befehl auszuführen. Erstellen wir einen Benutzer namens testuser01.
```
sudo useradd testuser01
```
Nachdem Sie den Benutzer erstellt haben, können Sie seine Existenz in /etc/passwd überprüfen und sein Home-Verzeichnis überprüfen.
```
grep testuser01 /etc/passwd
ls -ld /home/testuser01
```
Sie sollten eine Ausgabe ähnlich dieser sehen:
```
testuser01:x:1001:1001::/home/testuser01:/bin/bash
drwx------. 2 testuser01 testuser01 6 Mar  4 15:22 /home/testuser01
```
Standardmäßig haben neu erstellte Benutzer kein Passwort gesetzt, was bedeutet, dass sie sich nicht anmelden können. Sie müssen ein Passwort für testuser01 mit dem Befehl passwd festlegen.
```
sudo passwd testuser01
```
Sie werden aufgefordert, ein neues Passwort einzugeben. Verwenden Sie für dieses Lab labexrhel9 als Passwort für testuser01. Möglicherweise sehen Sie eine "BAD PASSWORD"-Warnung, aber Sie können fortfahren.
```
New password:
Retype new password:
passwd: all authentication tokens updated successfully.
```
Versuchen Sie nun, mit su - zu testuser01 zu wechseln.
```
su - testuser01
```
Geben Sie das Passwort labexrhel9 ein, wenn Sie dazu aufgefordert werden. Ihre Eingabeaufforderung sollte sich zu [testuser01@host ~]$ ändern.
```
Password:
[testuser01@host ~]$
```
Um zu Ihrem labex-Benutzer zurückzukehren, geben Sie exit ein.
```
exit
```

Als Nächstes ändern wir ein bestehendes Benutzerkonto mit dem Befehl usermod. Mit dem Befehl usermod können Sie verschiedene Eigenschaften eines Benutzers ändern, z. B. sein Home-Verzeichnis, seine Shell oder seine Gruppenmitgliedschaften.

Ändern wir das Kommentarfeld (vollständiger Name) für testuser01 in "Test User One".
```
sudo usermod -c "Test User One" testuser01
```
Überprüfen Sie die Änderung, indem Sie die Datei /etc/passwd erneut überprüfen.
```
grep testuser01 /etc/passwd
```
Die Ausgabe sollte nun den aktualisierten Kommentar widerspiegeln:
```
testuser01:x:1001:1001:Test User One:/home/testuser01:/bin/bash
```
Sie können auch ein Benutzerkonto sperren oder entsperren. Das Sperren eines Kontos verhindert, dass sich der Benutzer anmeldet, während das Entsperren die Anmeldung wieder aktiviert.

So sperren Sie das Konto testuser01:
```
sudo usermod -L testuser01
```
Versuchen Sie nun, sich erneut bei testuser01 anzumelden.
```
su - testuser01
```
Sie werden nach dem Passwort gefragt, aber selbst mit dem richtigen Passwort schlägt die Anmeldung fehl:
```
Password:
su: Authentication failure
```
So entsperren Sie das Konto testuser01:
```
sudo usermod -U testuser01
```
Versuchen Sie erneut, zu testuser01 zu wechseln, und es sollte erfolgreich sein. Denken Sie daran, exit einzugeben, um zu labex zurückzukehren.
```
su - testuser01
## Enter password 'labexrhel9'
exit
```

Schließlich löschen wir das von Ihnen erstellte Benutzerkonto.

Verwenden Sie den Befehl userdel, um einen Benutzer zu entfernen. Standardmäßig entfernt userdel den Eintrag des Benutzers aus /etc/passwd, lässt aber sein Home-Verzeichnis intakt. Dies kann zu verwaisten Dateien führen.
```
sudo userdel testuser01
```
Überprüfen Sie, ob der Benutzer aus /etc/passwd entfernt wurde, aber das Home-Verzeichnis noch existiert.
```
grep testuser01 /etc/passwd
ls -ld /home/testuser01
```
Der Befehl grep sollte keine Ausgabe zurückgeben, was darauf hindeutet, dass der Benutzer nicht mehr vorhanden ist. Der Befehl ls -ld zeigt, dass das Home-Verzeichnis noch existiert, aber sein Eigentum wird als numerische UIDs/GIDs angezeigt, da der Benutzer nicht mehr existiert.
```
drwx------ 2 1001 1001 83 Mar  4 15:22 /home/testuser01
```
Hinweis: In einigen RHEL-Versionen oder -Konfigurationen kann userdel das Home-Verzeichnis standardmäßig entfernen, wenn es leer ist oder wenn der Benutzer der alleinige Eigentümer war. Es ist jedoch sicherer, die Option -r explizit zu verwenden, um sicherzustellen, dass das Home-Verzeichnis entfernt wird.
Um den Benutzer und sein Home-Verzeichnis zu entfernen, verwenden Sie die Option -r mit userdel. Erstellen wir einen neuen Benutzer testuser02, um dies richtig zu demonstrieren.
```
sudo useradd testuser02
sudo passwd testuser02 ## You'll be prompted to enter 'labexrhel9'
```
Entfernen Sie nun testuser02 und sein Home-Verzeichnis:
```
sudo userdel -r testuser02
```
Überprüfen Sie, ob sowohl der Benutzereintrag als auch das Home-Verzeichnis entfernt wurden.
```
grep testuser02 /etc/passwd
ls -ld /home/testuser02
```
Beide Befehle sollten anzeigen, dass testuser02 und sein Home-Verzeichnis nicht mehr existieren.
```
ls: cannot access '/home/testuser02': No such file or directory
```

Dies schließt Ihre Übung mit dem Erstellen, Ändern und Löschen lokaler Benutzerkonten ab.

Lokale Gruppenkonten verwalten

In diesem Schritt lernen Sie, wie Sie lokale Gruppenkonten auf einem RHEL-System verwalten. Gruppen sind grundlegend für die effiziente Verwaltung von Berechtigungen und ermöglichen es Ihnen, mehreren Benutzern gleichzeitig Zugriff zu gewähren. Sie verwenden Befehle wie groupadd, groupmod und groupdel und wiederholen auch usermod für die Verwaltung von Benutzer-Gruppen-Mitgliedschaften.

Zuerst erstellen wir eine neue Gruppe.

Verwenden Sie den Befehl groupadd, um eine neue Gruppe zu erstellen. Standardmäßig weist groupadd die nächste verfügbare GID aus dem in /etc/login.defs angegebenen Bereich zu. Sie benötigen sudo-Rechte, um diesen Befehl auszuführen. Erstellen wir eine Gruppe namens developers.
```
sudo groupadd developers
```
Sie können die Erstellung der Gruppe überprüfen, indem Sie die Datei /etc/group überprüfen.
```
grep developers /etc/group
```
Sie sollten einen Eintrag ähnlich diesem sehen:
```
developers:x:1002:
```
Sie können auch eine bestimmte GID für die Gruppe mit der Option -g angeben. Erstellen wir eine weitere Gruppe namens testers mit einer bestimmten GID, z. B. 2000.
```
sudo groupadd -g 2000 testers
```
Überprüfen Sie die GID der Gruppe testers.
```
grep testers /etc/group
```
Die Ausgabe sollte die angegebene GID bestätigen:
```
testers:x:2000:
```

Als Nächstes ändern wir eine bestehende Gruppe mit dem Befehl groupmod.

Sie können den Namen einer Gruppe mit der Option -n ändern. Benennen wir testers in qa_team um.
```
sudo groupmod -n qa_team testers
```
Überprüfen Sie die Namensänderung in /etc/group.
```
grep qa_team /etc/group
```
Die Ausgabe sollte den neuen Namen mit der ursprünglichen GID anzeigen:
```
qa_team:x:2000:
```
Sie können auch die GID einer Gruppe mit der Option -g ändern. Ändern wir die GID von qa_team in 2001.
```
sudo groupmod -g 2001 qa_team
```
Überprüfen Sie die GID-Änderung.
```
grep qa_team /etc/group
```
Die Ausgabe sollte die neue GID widerspiegeln:
```
qa_team:x:2001:
```

Nun verwalten wir die Benutzermitgliedschaften innerhalb dieser Gruppen. Sie verwenden dafür den Befehl usermod. Erstellen Sie zuerst ein paar Testbenutzer.

Erstellen Sie userA und userB und setzen Sie ihre Passwörter auf labexrhel9.
```
sudo useradd userA
sudo passwd userA
```
Geben Sie labexrhel9 als Passwort für userA ein.
```
sudo useradd userB
sudo passwd userB
```
Geben Sie labexrhel9 als Passwort für userB ein.
Fügen Sie userA der Gruppe developers als sekundäre Gruppe hinzu. Verwenden Sie die Optionen -a (anhängen) und -G (Gruppen) mit usermod.
```
sudo usermod -aG developers userA
```
Überprüfen Sie die Gruppenmitgliedschaften von userA mit dem Befehl id.
```
id userA
```
Sie sollten developers im Abschnitt groups sehen:
```
uid=1003(userA) gid=1003(userA) groups=1003(userA),1002(developers)
```
Fügen Sie userB sowohl den Gruppen developers als auch qa_team als sekundäre Gruppen hinzu.
```
sudo usermod -aG developers,qa_team userB
```
Überprüfen Sie die Gruppenmitgliedschaften von userB.
```
id userB
```
Sie sollten sowohl developers als auch qa_team aufgelistet sehen:
```
uid=1004(userB) gid=1004(userB) groups=1004(userB),1002(developers),2001(qa_team)
```
Sie können auch die primäre Gruppe eines Benutzers mit der Option -g mit usermod ändern. Ändern wir die primäre Gruppe von userA in developers.
```
sudo usermod -g developers userA
```
Überprüfen Sie die primäre Gruppe von userA.
```
id userA
```
Das Feld gid sollte nun developers anzeigen:
```
uid=1003(userA) gid=1002(developers) groups=1002(developers)
```
Hinweis: Wenn Sie die primäre Gruppe eines Benutzers ändern, wird er aus der Mitgliedsliste seiner alten primären Gruppe in /etc/group entfernt, wenn diese Gruppe auch eine sekundäre Gruppe war. In diesem Fall wird die ursprüngliche primäre Gruppe von userA (userA) nicht mehr als sekundäre Gruppe aufgeführt.

Schließlich löschen wir die von Ihnen erstellten Gruppen und Testbenutzer.

Verwenden Sie den Befehl groupdel, um eine Gruppe zu entfernen. Sie können eine Gruppe nicht löschen, wenn sie die primäre Gruppe für einen Benutzer ist. Ändern Sie zuerst die primäre Gruppe von userA zurück auf ihre Standardeinstellung (oder eine andere vorhandene Gruppe), bevor Sie developers löschen.
```
sudo usermod -g userA userA ## Change userA's primary group back to userA
sudo groupdel developers
```
Überprüfen Sie, ob developers aus /etc/group entfernt wurde.
```
grep developers /etc/group
```
Dieser Befehl sollte keine Ausgabe zurückgeben.
Löschen Sie die Gruppe qa_team.
```
sudo groupdel qa_team
```
Überprüfen Sie die Entfernung.
```
grep qa_team /etc/group
```
Dieser Befehl sollte ebenfalls keine Ausgabe zurückgeben.

Bereinigen Sie die Testbenutzer.

sudo userdel -r userA
sudo userdel -r userB

Dies schließt Ihre Übung mit der Verwaltung lokaler Gruppenkonten und Benutzer-Gruppen-Mitgliedschaften ab.

Benutzer-Passwortrichtlinien konfigurieren

In diesem Schritt lernen Sie, wie Sie Benutzer-Passwortrichtlinien auf einem RHEL-System konfigurieren. Passwortrichtlinien sind entscheidend für die Erhöhung der Sicherheit, indem Regeln für die Passwortkomplexität, den Ablauf und die Kontosperrung durchgesetzt werden. Sie werden die Datei /etc/shadow und den Befehl chage untersuchen.

Zuerst wollen wir die Datei /etc/shadow verstehen, in der verschlüsselte Passwortinformationen und Parameter zur Passwortalterung für Benutzerkonten gespeichert werden. Diese Datei ist sehr sensibel und nur für den Benutzer root lesbar.

Jeder Benutzer hat einen Eintrag in der Datei /etc/shadow. Erstellen wir einen neuen Benutzer policyuser und setzen wir sein Passwort zu Demonstrationszwecken auf labexrhel9.
```
sudo useradd policyuser
sudo passwd policyuser
```
Geben Sie labexrhel9 als Passwort für policyuser ein.
Zeigen Sie nun den Eintrag für policyuser in /etc/shadow an.
```
sudo grep policyuser /etc/shadow
```
Sie sehen eine Ausgabe ähnlich dieser:
```
policyuser:$6$randomsalt$encryptedhash:19780:0:99999:7:::
```
Lassen Sie uns jedes Feld aufschlüsseln, getrennt durch einen Doppelpunkt:
- policyuser: Name des Benutzerkontos.
- $6$randomsalt$encryptedhash: Das verschlüsselte Passwort des Benutzers.
  - $6: Der Hashing-Algorithmus, der für dieses Passwort verwendet wird (SHA-512, der RHEL 9-Standard).
  - randomsalt: Das Salt, das zum Verschlüsseln des Passworts verwendet wird; ursprünglich zufällig ausgewählt.
  - encryptedhash: Der verschlüsselte Hash des Passworts des Benutzers.
- 19780: Die Tage seit der Epoche (1970-01-01 UTC), an dem das Passwort zuletzt geändert wurde. Diese Zahl variiert je nach aktuellem Datum.
- 0: Die Mindestanzahl an Tagen seit der letzten Passwortänderung, bevor der Benutzer es erneut ändern kann.
- 99999: Die maximale Anzahl an Tagen ohne Passwortänderung, bevor das Passwort abläuft. Ein leeres Feld bedeutet, dass das Passwort nie abläuft.
- 7: Die Anzahl der Tage im Voraus, um den Benutzer zu warnen, dass sein Passwort abläuft.
- (leer): Die Anzahl der Tage ohne Aktivität, beginnend mit dem Tag, an dem das Passwort abgelaufen ist, bevor das Konto automatisch gesperrt wird.
- (leer): Der Tag, an dem das Konto in Tagen seit der Epoche abläuft. Ein leeres Feld bedeutet, dass das Konto nie abläuft.
- Das letzte Feld ist typischerweise leer und für die zukünftige Verwendung reserviert.

Als Nächstes verwenden Sie den Befehl chage, um diese Parameter zur Passwortalterung zu ändern. Mit dem Befehl chage können Sie Informationen zum Ablauf des Benutzerpassworts ändern.

Legen wir eine Passwortrichtlinie für policyuser mit den folgenden Regeln fest:
- Mindestanzahl an Tagen zwischen Passwortänderungen: 7 Tage (-m 7)
- Maximale Anzahl an Tagen zwischen Passwortänderungen: 90 Tage (-M 90)
- Warnzeitraum vor Ablauf des Passworts: 14 Tage (-W 14)
- Inaktivitätszeitraum nach Ablauf des Passworts, bevor das Konto gesperrt wird: 30 Tage (-I 30)
```
sudo chage -m 7 -M 90 -W 14 -I 30 policyuser
```

Um diese Änderungen zu überprüfen, können Sie chage -l (list) verwenden, um die aktuellen Informationen zur Passwortalterung für policyuser anzuzeigen.

sudo chage -l policyuser

Sie sollten eine Ausgabe sehen, die die neue Richtlinie widerspiegelt:

Last password change					: Mar 04, 2024
Password expires					: Jun 02, 2024
Password inactive					: Jul 02, 2024
Account expires						: never
Minimum number of days between password change		: 7
Maximum number of days between password change		: 90
Number of days of warning before password expires	: 14

Hinweis: Die Daten variieren je nachdem, wann Sie das Lab durchführen.

Sie können auch ein absolutes Ablaufdatum für das Konto mit der Option -E festlegen. Legen wir fest, dass das Konto von policyuser in 30 Tagen ab heute abläuft. Ermitteln Sie zuerst das heutige Datum und berechnen Sie das Datum in 30 Tagen.
```
EXPIRY_DATE=$(date -d "+30 days" +%Y-%m-%d)
echo "Account will expire on: $EXPIRY_DATE"
sudo chage -E $EXPIRY_DATE policyuser
```
Überprüfen Sie das Ablaufdatum des Kontos.
```
sudo chage -l policyuser | grep "Account expires"
```
Die Ausgabe sollte das berechnete Ablaufdatum anzeigen:
```
Account expires						: Apr 03, 2024
```
Hinweis: Das Datum liegt ungefähr 30 Tage nach Ihrem aktuellen Lab-Datum.
Um das Ablaufdatum des Kontos zu entfernen, können Sie chage -E -1 policyuser verwenden.
```
sudo chage -E -1 policyuser
sudo chage -l policyuser | grep "Account expires"
```
Die Ausgabe sollte wieder auf never zurückgesetzt werden:
```
Account expires						: never
```

Schließlich bereinigen Sie das Konto policyuser.

sudo userdel -r policyuser

Dies schließt Ihre Übung mit der Konfiguration von Benutzer-Passwortrichtlinien ab. Sie verstehen jetzt, wie Sie Parameter zur Passwortalterung mithilfe der Datei /etc/shadow und des Befehls chage untersuchen und ändern können.

Zusammenfassung

In diesem Lab haben Sie grundlegende Konzepte der Benutzer- und Gruppenverwaltung in Red Hat Enterprise Linux (RHEL) gelernt. Sie begannen damit, zu verstehen, wie Benutzer und Gruppen mit Dateien und Prozessen verknüpft sind, und wie Sie Benutzer- und Gruppeninformationen mithilfe des Befehls id sowohl für den aktuellen Benutzer als auch für andere Systembenutzer wie root überprüfen können. Sie haben auch geübt, Dateieigentümer und Verzeichniseigentümer mithilfe der Befehle ls -l bzw. ls -ld zu identifizieren, was für das Verständnis von Berechtigungen und Zugriffskontrolle unerlässlich ist.

Das Lab führte Sie weiter durch das Erhalten von Superuser-Zugriff, das Erstellen und Ändern lokaler Benutzerkonten, das Verwalten lokaler Gruppenkonten und das Konfigurieren von Benutzer-Passwortrichtlinien. Diese Schritte boten praktische Erfahrung in wesentlichen Systemadministrationsaufgaben und ermöglichten es Ihnen, den Benutzerzugriff und die Sicherheit auf einem Linux-System effektiv zu verwalten.