---
id: 2024-10-27-linux-administration-fortgeschrittene-benutzerverwaltung
slug: linux-administration-fortgeschrittene-benutzerverwaltung
title: "Linux Administration #2: Fortgeschrittene Benutzerverwaltung"
excerpt: "Dieser Artikel behandelt fortgeschrittene Aspekte der Linux-Benutzerverwaltung, von PAM-Konfiguration über Benutzerquotas bis hin zu ACLs und der Überwachung von Benutzeraktivitäten."
date: "2024-10-27T09:00:00+01:00"
updated: "2024-10-27T10:00:00+01:00"
author:
  name: "Sebastian Palencsar"
  handle: "spalencsar"
category: "linux-administration"
tags: ["user-management", "acl", "pam", "sudo", "groups", "security", "linux-administration"]
toc: true
reading_time: 16
---

**Willkommen zum zweiten Teil unserer technischen Wiki-Serie über Linux-Administration!**

Nachdem wir im ersten Artikel die <span class="badge-inline">[Grundlagen der Benutzer- und Rechteverwaltung](/de/linux-administration/linux-administration-grundlagen-der-linux-administration)</span> kennengelernt haben, tauchen wir nun tiefer in die fortgeschrittenen Aspekte ein. Die fortgeschrittene Benutzerverwaltung umfasst alle Werkzeuge und Konzepte, die über die grundlegende Erstellung und Löschung von Benutzerkonten hinausgehen.

## Stell dir ein großes Unternehmen vor 

Die einfache Benutzerverwaltung wäre wie ein Pförtner, der Ausweise ausstellt. Die fortgeschrittene Benutzerverwaltung hingegen ist wie ein komplettes Sicherheitssystem mit Zugangskontrolle, Überwachung und automatischer Verwaltung.

<blockquote class="infobox infobox--important">
⚠️ <strong>Hinweis:</strong> In diesem Artikel verwenden wir Ubuntu/Debian als Beispiel-Distribution. Die grundlegenden Konzepte sind auf allen Linux-Systemen gleich, aber die Installation von Paketen und einige Konfigurationspfade können sich je nach Distribution unterscheiden. Wenn du eine andere Distribution verwendest, konsultiere bitte die entsprechende Dokumentation für die spezifischen Installationsbefehle und Pfade.
</blockquote>

## Benötigte Pakete installieren

**Installation der PAM-Module für erweiterte Passwort-Policies**

```Bash
sudo apt install libpam-pwquality cracklib-runtime
```

**Überprüfen der Installation**

```Bash
dpkg -l | grep libpam-pwquality
dpkg -l | grep cracklib
```

**Was wird installiert?**

`libpam-pwquality`: Modul für erweiterte Passwort-Qualitätsprüfungen
`cracklib-runtime`: Wörterbuch-basierte Passwortprüfung

**Wichtige Konfigurationsdateien:**

```Markdown
/etc/security/
├── pwquality.conf     # Hauptkonfiguration für Passwort-Qualität
└── pwquality.conf.d/  # Zusätzliche Konfigurationsdateien
```

## Passwort-Policies verstehen

Eine Passwort-Policy ist wie ein Regelwerk für sichere Passwörter:

```Markdown
Passwort-Policy-Komponenten:
┌─────────── Komplexität ────────────┐
│ - Minimale Länge                   │
│ - Zeichenarten                     │
│ - Wiederholungsregeln              │
├─────────── Lebenszyklus ───────────┤
│ - Gültigkeitsdauer                 │
│ - Historie                         │
│ - Änderungsintervalle              │
└────────────────────────────────────┘
```

##### Passwort-Policy-Konfiguration

In der fortgeschrittenen Benutzerverwaltung ist die Einrichtung sicherer Passwort-Richtlinien entscheidend. Stell dir die Passwort-Policy wie einen Sicherheitsstandard in einem Gebäude vor.

###### Grundlegende Passwort-Policy verstehen

```Markdown
Passwort-Komponenten:
┌─────────── Komplexität ──────────────┐
│ - Minimale Länge                     │
│ - Zeichenarten (A-Z, a-z, 0-9, @#$)  │
│ - Wörterbuch-Prüfung                 │
├─────────── Gültigkeit ───────────────┤
│ - Maximales Alter                    │
│ - Minimales Alter                    │
│ - Warnzeit vor Ablauf                │
├─────────── Historie ─────────────────┤
│ - Anzahl alter Passwörter            │
│ - Wiederverwendungssperre            │
└──────────────────────────────────────┘
```

#### PAM-Konfiguration für Passwort-Policies

PAM (Pluggable Authentication Modules) ist das Herzstück der Authentifizierung in Linux. Es ermöglicht die flexible Konfiguration von Sicherheitsrichtlinien.

###### PAM verstehen

```Markdown
PAM-Struktur:
┌─────────── Authentifizierung ────────────┐
│ auth       Identitätsprüfung             │
├─────────── Account ──────────────────────┤
│ account    Kontozugang & -status         │
├─────────── Password ─────────────────────┤
│ password   Passwortänderungen            │
├─────────── Session ──────────────────────┤
│ session    Sitzungsverwaltung            │
└──────────────────────────────────────────┘
```

##### Passwort-Qualitätsrichtlinien einrichten

**Hauptkonfigurationsdatei:**

Konfigurationsdatei öffnen

```Bash
sudo nano /etc/security/pwquality.conf
```

Wichtige Parameter:

```TypeScript
minlen = 12          # Minimale Passwortlänge
minclass = 3         # Mindestens 3 verschiedene Zeichenklassen
maxrepeat = 2        # Maximal 2 gleiche Zeichen hintereinander
gecoscheck = 1       # Prüft auf Benutzernamen im Passwort
dictcheck = 1        # Aktiviert Wörterbuchprüfung
```

##### PAM-Module für Passwörter konfigurieren

**PAM-Konfiguration für Passwörter**

```Bash
sudo nano /etc/pam.d/common-password
```

**Beispielkonfiguration**

```TypeScript
password    required    pam_pwquality.so retry=3
password    required    pam_unix.so use_authtok sha512 shadow remember=5
```

##### Passwort-Historie und Ablaufverwaltung

Die Verwaltung der Passwort-Historie und Ablaufzeiten ist ein wichtiger Bestandteil der Sicherheit:

```Markdown
Passwort-Lebenszyklus:
┌─────────── Erstellung ─────────────┐
│ Tag 0: Neues Passwort gesetzt      │
├─────────── Nutzung ────────────────┤
│ Tag 1-75: Normale Nutzung          │
├─────────── Warnung ────────────────┤
│ Tag 76-89: Ablaufwarnung           │
├─────────── Ablauf ─────────────────┤
│ Tag 90: Passwort muss geändert     │
└────────────────────────────────────┘
```

###### Passwort-Historie konfigurieren

In `/etc/pam.d/common-password`:

```TypeScript
password required pam_pwhistory.so remember=5 enforce_for_root use_authtok
```

**Parameter erklärt:**

```Markdown
remember=5           # Speichert die letzten 5 Passwörter
enforce_for_root     # Gilt auch für root
use_authtok          # Verwendet Token vom vorherigen Modul
```

###### Passwort-Ablauf einrichten

in `/etc/login.defs`

```TypeScript
PASS_MAX_DAYS   90      # Maximales Alter
PASS_MIN_DAYS   1       # Minimales Alter
PASS_WARN_AGE   14      # Warnzeit vor Ablauf
```

**Für einzelne Benutzer:**

```Bash
sudo chage -M 90 -m 1 -W 14 username
```

###### Detaillierte Ablaufkonfiguration

Benutzerdetails anzeigen:

```Bash
sudo chage -l username
```

**Ausgabe Beispiel:**

```Bash
Last password change                    : Jan 01, 2024
Password expires                        : Apr 01, 2024
Password inactive                       : never
Account expires                         : never
Minimum number of days between changes  : 1
Maximum number of days between changes  : 90
Number of days of warning before expire : 14
```

### Häufige Probleme bei der Passwort-Policy

**Problem:** Passwortänderung schlägt fehl

```Bash
# Fehlermeldung bei Passwortänderung:
passwd
# Ausgabe: "Password does not meet complexity requirements"

# Überprüfen der aktuellen Policy:
sudo cat /etc/security/pwquality.conf | grep -v '^#'
```

**Häufige Ursachen:**

┌ Passwort zu kurz
├ Fehlende Zeichenklassen
├ Enthält Benutzername
├ Zu ähnlich zum alten Passwort
└ Passwort-Historie verletzt

**Problem:** Benutzer kann sich nicht anmelden

```Bash
# Überprüfen des Passwort-Status
sudo chage -l username

# Häufige Ursachen und Lösungen:
# 1. Passwort abgelaufen
sudo chage -d 0 username  # Erzwingt Änderung beim Login

# 2. Account gesperrt
sudo usermod -U username  # Account entsperren

# 3. PAM-Konfiguration prüfen
sudo cat /etc/pam.d/common-auth
```

### Praktische Beispiele

**Szenario 1:** Entwicklungsteam-Setup

```Bash
# Passwort-Policy für Entwickler
sudo nano /etc/security/pwquality.conf

minlen = 14
minclass = 3
maxrepeat = 2
enforce_for_root

# Passwort-Alter für sensible Projekte
sudo chage -M 60 -m 1 -W 7 developer1
```

**Szenario 2:** Temporäre Mitarbeiter

```Bash
# Ablaufdatum setzen
sudo useradd -e 2024-12-31 tempuser
# oder für existierenden Benutzer
sudo chage -E 2024-12-31 tempuser

# Status überprüfen
sudo chage -l tempuser
```

**Szenario 3:** Automatische Passwortänderung erzwingen

Neue Mitarbeiter sollen ihr initiales Passwort beim ersten Login ändern.

```Bash
# Passwort-Änderung erzwingen
sudo chage -d 0 newuser

# Überprüfen der Einstellungen
sudo chage -l newuser
```

**Szenario 4:** Temporäre Zugänge

Praktikanten brauchen Zugang für 3 Monate.

```Bash
# Benutzer mit Ablaufdatum erstellen
sudo useradd -e $(date -d "+3 months" +%Y-%m-%d) intern01

# Warnung 14 Tage vor Ablauf
sudo chage -W 14 intern01

# Status überprüfen
sudo chage -l intern01
```

**Szenario 5:** Passwort-Historie durchsetzen

```Bash
# PAM-Konfiguration anpassen
sudo nano /etc/pam.d/common-password

# Folgende Zeile hinzufügen/anpassen:
password required pam_pwhistory.so remember=5 use_authtok

# Parameter erklärt:
remember=5      # Speichert die letzten 5 Passwörter
use_authtok     # Verwendet vorheriges PAM-Token
```

## Benutzerquotas implementieren

Quotas sind wie Speicherlimits für Benutzer und Gruppen. Sie helfen, die Ressourcennutzung zu kontrollieren.

```Markdown
Quota-Typen:
┌─────────── Block Quotas ─────────────┐
│ Begrenzt Speicherplatz               │
│ Beispiel: 5GB pro Benutzer           │
├─────────── Inode Quotas ─────────────┤
│ Begrenzt Anzahl der Dateien          │
│ Beispiel: Max. 50.000 Dateien        │
└──────────────────────────────────────┘
```

##### Quota-System aktivieren

###### Quota-Unterstützung installieren

```Bash
sudo apt install quota quotatool
```

**`/etc/fstab` anpassen**

```TypeScript
# Füge usrquota,grpquota zu den Mount-Optionen hinzu
sudo nano /etc/fstab
# Beispiel:
# /dev/sda1  /home  ext4  defaults,usrquota,grpquota  0  2
```

**Filesystem neu einbinden**

```Bash
sudo mount -o remount /home
```

##### Quotas einrichten

###### Quota-Datenbanken erstellen

```Bash
sudo quotacheck -cugm /home
```

**Quotas aktivieren**

```Bash
sudo quotaon -v /home
```

**Quota für Benutzer setzen**

```Bash
sudo edquota -u username

# Soft limit: Warnung
# Hard limit: Strikte Grenze
```

##### Erweiterte Quota-Konfigurationen

###### Soft und Hard Limits verstehen:

_Quota für einen Benutzer bearbeiten_:

```Bash
sudo edquota -u username
```

**Beispiel-Ausgabe:**

```Bash
Filesystem  blocks  soft    hard   inodes  soft  hard
/dev/sda1   500000  524288  786432  1000   1500  2000
		  ├─Aktuell┤└─Warn─┘└─Limit┘└─Dateien──────┘
```

**Bedeutung**:

- `blocks`: Aktueller Speicherverbrauch
- `soft`: Warnung bei Überschreitung
- `hard`: Absolutes Limit
- `inodes`: Anzahl der Dateien

###### Gruppenquotas verwalten:

```Bash
# Quota für eine Gruppe setzen
sudo edquota -g entwickler

# Quota-Status für Gruppe anzeigen
sudo quota -g entwickler

# Quota-Report für alle Gruppen
sudo repquota -g /home
```

###### Quota-Warnungen konfigurieren:

Grace Period einstellen:

```Bash
sudo edquota -t
```

**Beispiel:**

```Bash
Filesystem    Block grace period    Inode grace period
/dev/sda1     7days                 7days

# 7 Tage Zeit zwischen Soft und Hard Limit
```

##### Praktische Quota-Szenarien

###### Entwicklungsteam-Setup

Entwickler bekommen großzügige Limits:

```Bash
sudo edquota -u entwickler1
```

**Beispiel:**

```Bash
Filesystem  blocks   soft    hard   inodes   soft   hard
/dev/sda1   500000  5242880 6291456  10000   50000  75000

# Bedeutung:
# - 5GB soft limit (Warnung)
# - 6GB hard limit (Strict)
# - 50.000 Dateien soft limit
# - 75.000 Dateien hard limit
```

###### Praktikanten-Setup

Begrenzte Ressourcen für temporäre Mitarbeiter:

```Bash
sudo edquota -u praktikant1
```

**Beispiel:**

```Bash
Filesystem  blocks  soft    hard   inodes  soft  hard
/dev/sda1   100000  524288  786432   1000   2000  3000
```

Template für alle Praktikanten erstellen:

```Bash
sudo edquota -p praktikant1 praktikant2 praktikant3
```

##### Projekt-Quotas

Projektverzeichnis mit Gruppenquota:

```Bash
sudo edquota -g projektgruppe
```

**Beispiel:**

```Bash
Filesystem  blocks   soft     hard    inodes  soft   hard
/dev/sda1   1000000 10485760 15728640  20000  50000 75000
```

Quota-Report für das Projekt:

```Bash
sudo repquota -g /home | grep projektgruppe
```

##### Quota-Überwachung und -Verwaltung

```Bash
# Quota-Status für einen Benutzer anzeigen
sudo quota -v username

# Quota-Report für alle Benutzer
sudo repquota -a /home

# Detaillierte Quota-Statistiken
sudo quota -vs username
```

###### Quota-Warnungen und Benachrichtigungen:

```Bash
# Warnmeldungen konfigurieren
sudo edquota -t
# Grace Period einstellen (Karenzzeit nach Überschreitung)

# E-Mail-Benachrichtigungen einrichten
sudo nano /etc/quotamail.conf
```

###### Praktisches Monitoring-Beispiel:

```TypeScript
#!/bin/bash
# Quota-Überwachungsskript

# Benutzer über 80% Auslastung finden
repquota -a | awk '$4 > 80 {print $1": "$4"%"}'

# Warnung an Benutzer senden
for user in $(repquota -a | awk '$4 > 80 {print $1}')
do
	echo "Warnung: Quota fast erschöpft" | mail -s "Quota-Warnung" $user
done
```

## Access Control Lists (ACLs)

ACLs erweitern das traditionelle Linux-Berechtigungssystem um feingranulare Zugriffskontrollen.

**Voraussetzungen:**

```Bash
sudo apt install acl
```

##### ACL-Konzepte verstehen

```Markdown
ACL-Typen:
┌─────────── Erweiterte ACLs ────────────┐
│ - Zusätzliche Benutzerrechte           │
│ - Zusätzliche Gruppenrechte            │
│ - Vererbbare Berechtigungen            │
├─────────── Maske ──────────────────────┤
│ - Maximale effektive Rechte            │
│ - Überschreibt andere ACL-Einträge     │
└────────────────────────────────────────┘
```

##### ACL-Verwaltung

**ACLs für bestehende Verzeichnisstruktur**

```Bash
sudo setfacl -R -m g:entwickler:rwx /projekte/webapp/
sudo setfacl -R -m g:qa:rx /projekte/webapp/
```

**Vererbung einrichten**

```Bash
sudo setfacl -d -m g:entwickler:rwx /projekte/webapp/
```

##### Praktische ACL-Anwendungsfälle

###### Entwicklungsprojekt-Setup

```Bash
# Projektstruktur erstellen
sudo mkdir -p /projekte/webapp/{src,docs,config}

# Basis-ACLs für Entwicklerteam
sudo setfacl -m g:entwickler:rwx /projekte/webapp/src
sudo setfacl -m g:entwickler:rwx /projekte/webapp/docs

# Spezielle Rechte für QA-Team
sudo setfacl -m g:qa:rx /projekte/webapp/src
sudo setfacl -m g:qa:r /projekte/webapp/docs

# Konfigurationsverzeichnis mit beschränktem Zugriff
sudo setfacl -m g:admin:rwx,g:entwickler:r /projekte/webapp/config
```

##### ACLs verwalten

```Bash
# ACL für eine Datei anzeigen
getfacl datei.txt

# ACL setzen
# Syntax: setfacl -m u:username:rwx datei
setfacl -m u:anna:rw- projekt.txt
setfacl -m g:entwickler:r-x scripts/

# Mehrere ACL-Einträge
setfacl -m u:anna:rw-,g:projekt:r-- datei.txt

# Rekursive ACLs für Verzeichnisse
setfacl -R -m g:entwickler:rwx /projekte/
```

##### Praktische ACL-Beispiele

###### Standard-ACLs für ein Projektverzeichnis

```Bash
# Projektverzeichnis erstellen
sudo mkdir -p /projekte/webapp

# Basis-ACLs setzen
# Entwickler haben vollen Zugriff
# QA-Team hat Lese- und Ausführrechte
sudo setfacl -m g:entwickler:rwx,g:qa:rx /projekte/webapp

# Standard-ACLs für neue Dateien
sudo setfacl -d -m g:entwickler:rwx,g:qa:rx /projekte/webapp

# ACLs überprüfen
getfacl /projekte/webapp
```

###### Geteiltes Dokumentenverzeichnis

```Bash
# Dokumentenstruktur
sudo mkdir -p /dokumente/{public,team,management}

# Public: Alle können lesen
sudo setfacl -m g:users:rx /dokumente/public
sudo setfacl -d -m g:users:rx /dokumente/public

# Team: Nur Teammitglieder
sudo setfacl -m g:team:rwx /dokumente/team
sudo setfacl -d -m g:team:rwx /dokumente/team

# Management: Nur bestimmte Personen
sudo setfacl -m u:chef:rwx,u:sekretariat:rx /dokumente/management
```

###### ACLs für verschiedene Anwendungsfälle

Gemeinsames Dokumentenverzeichnis:

```Bash
# Verzeichnisstruktur:
/dokumente/
├── public/     # Alle können lesen
├── team/       # Nur Teammitglieder
└── private/    # Nur spezifische Benutzer

# ACLs setzen
sudo setfacl -R -m g:users:rx /dokumente/public
sudo setfacl -R -m g:team:rwx /dokumente/team
sudo setfacl -m u:chef:rwx,u:sekretariat:rx /dokumente/private
```

##### Weitere praktische ACL-Beispiele

###### Komplexe Projektstruktur mit ACLs

```Bash
# Projektstruktur erstellen
sudo mkdir -p /projekte/webapp/{src,docs,config,tests}

# Basis-Berechtigungen
sudo chown -R root:entwickler /projekte/webapp
sudo chmod 2775 /projekte/webapp

# Differenzierte ACLs setzen
# Entwickler haben vollen Zugriff auf src und tests
sudo setfacl -R -m g:entwickler:rwx /projekte/webapp/src
sudo setfacl -R -m g:entwickler:rwx /projekte/webapp/tests

# QA-Team hat Lese- und Ausführrechte für tests
sudo setfacl -R -m g:qa:rx /projekte/webapp/tests

# Dokumentation für alle lesbar
sudo setfacl -R -m g:users:rx /projekte/webapp/docs

# Config nur für Administratoren
sudo setfacl -R -m g:admin:rwx,g:entwickler:r /projekte/webapp/config
```

###### ACL-Vererbung für neue Dateien

```Bash
# Standard-ACLs für neue Dateien setzen
sudo setfacl -d -m g:entwickler:rwx /projekte/webapp/src
sudo setfacl -d -m g:qa:rx /projekte/webapp/tests

# ACL-Vererbung überprüfen
getfacl /projekte/webapp/src
```

## Benutzeraktivitäten überwachen

Die Überwachung von Benutzeraktivitäten ist ein wichtiger Aspekt der Systemsicherheit und -verwaltung.

**Voraussetzungen**:

```Bash
sudo apt install auditd audispd-plugins
```

##### Benutzeraktivitäten verstehen

```Markdown
Monitoring-Bereiche:
┌─────────── Login/Logout ─────────────┐
│ - Anmeldeversuche                    │
│ - Erfolgreiche/fehlgeschlagene       │
│ - SSH-Zugriffe                       │
├─────────── Aktivitäten ──────────────┤
│ - Ausgeführte Befehle                │
│ - Dateizugriffe                      │
│ - Ressourcennutzung                  │
└──────────────────────────────────────┘
```

##### Login-Überwachung

```Bash
# Aktuelle Login-Sessions
who
w

# Login-Historie
last
last -f /var/log/wtmp    # Erfolgreiche Logins
lastb                    # Fehlgeschlagene Logins

# SSH-Zugriffe überwachen
tail -f /var/log/auth.log | grep sshd
```

##### Benutzeraktivitäten aufzeichnen

```Bash
# Audit-System aktivieren
sudo apt install auditd

# Audit-Regeln hinzufügen
sudo auditctl -w /etc/passwd -p wa -k user-modify
sudo auditctl -w /etc/group -p wa -k group-modify

# Audit-Logs anzeigen
sudo ausearch -k user-modify
sudo aureport --auth     # Authentifizierungsbericht
```

##### Ressourcennutzung überwachen

```Bash
# Prozesse eines Benutzers
ps -u username

# Ressourcenverbrauch
top -u username
iotop -u username        # I/O-Aktivität

# Detaillierte Prozessanalyse
sudo ps auxf | grep username
```

##### Erweiterte Monitoring-Tools

###### Prozess-Monitoring mit auditd:

```Bash
# Prozess-Überwachung einrichten
sudo auditctl -a exit,always -F arch=b64 -S execve -k cmd_exec

# Benutzeraktionen überwachen
sudo ausearch -k cmd_exec
sudo aureport -x --summary

# Detaillierte Prozessanalyse
sudo ausearch -k cmd_exec -i | grep username
```

###### Login-Monitoring mit fail2ban:

```Bash
# Installation
sudo apt install fail2ban

# Konfiguration prüfen
sudo fail2ban-client status
sudo fail2ban-client status sshd

# Geblockte IPs anzeigen
sudo fail2ban-client get sshd banip
```

###### Ressourcen-Monitoring:

```Bash
# CPU und Memory pro Benutzer
top -U username

# Disk-Nutzung pro Benutzer
sudo du -sh /home/*

# Netzwerkaktivität
sudo nethogs
sudo iftop
```

##### Echtzeit-Überwachung

###### System Activity Reporter (SAR):

```Bash
# Installation
sudo apt install sysstat

# Aktivitäten aufzeichnen
sudo sar -u 1 5    # CPU-Nutzung alle 1 Sekunde, 5 Mal
sudo sar -r 1 5    # Speichernutzung
sudo sar -b 1 5    # I/O-Statistiken
```

###### Prozess-Tracking:

```Bash
# Prozess-Baum eines Benutzers
pstree username

# Detaillierte Prozessinformationen
ps auxf | grep username

# Kontinuierliche Überwachung
watch -n 1 'ps aux | grep username'
```

## Integration Monitoring-Tools

##### Zentrales Logging-System

```Bash
# Rsyslog für zentrales Logging konfigurieren
sudo nano /etc/rsyslog.d/auth-logging.conf

# Beispielkonfiguration:
auth,authpriv.*                 /var/log/auth.log
# Benutzeraktivitäten protokollieren
*.*;auth,authpriv.none          -/var/log/syslog
```

##### **Automatisiertes Monitoring-Skript:**

```ShellScript
#!/bin/bash
# user-monitor.sh

# Benutzeraktivitäten überwachen
echo "=== Täglicher Benutzeraktivitätsbericht ===" > /var/log/user-report.txt
date >> /var/log/user-report.txt

# Login-Versuche
echo "Fehlgeschlagene Logins:" >> /var/log/user-report.txt
grep "Failed password" /var/log/auth.log >> /var/log/user-report.txt

# Sudo-Nutzung
echo "Sudo-Verwendung:" >> /var/log/user-report.txt
grep "sudo:" /var/log/auth.log >> /var/log/user-report.txt

# Ressourcennutzung pro Benutzer
echo "Ressourcenverbrauch:" >> /var/log/user-report.txt
ps aux --sort=-%cpu | head -n 5 >> /var/log/user-report.txt
```

**Automatische Benachrichtigungen:**

```Bash
# Warnung bei verdächtigen Aktivitäten
if grep -q "Failed password" /var/log/auth.log; then
	echo "Warnung: Fehlgeschlagene Login-Versuche" | \
	mail -s "Sicherheitswarnung" admin@localhost
fi
```

## Troubleshooting

##### Häufige PAM-Probleme und Lösungen

###### PAM-Konfigurationsprobleme

**Problem:** PAM-Authentifizierung schlägt fehl

```Bash
# Fehlermeldung:
# Authentication token manipulation error

# Schrittweise Diagnose:
# 1. PAM-Logs prüfen
sudo tail -f /var/log/auth.log

# 2. PAM-Module überprüfen
ldd /usr/lib/pam/pam_pwquality.so

# 3. PAM-Konfiguration testen
sudo pam-auth-update --verbose
```

###### Berechtigungsprobleme

**Problem:** Shadow-Passwort-Zugriff

```Bash
# Fehlermeldung:
# Authentication service cannot retrieve authentication info

# Lösungen:
# 1. Shadow-Datei-Berechtigungen prüfen
ls -l /etc/shadow
# Sollte sein: -rw-r----- root:shadow

# 2. PAM-Shadow-Modul prüfen
sudo ls -l /lib/x86_64-linux-gnu/security/pam_unix.so
```

#### Praktische Lösungsbeispiele

**Problem:** Passwort-Historie umgehen (für Notfälle)

```Bash
sudo nano /etc/pam.d/common-password
# remember=5 temporär auskommentieren
```

**Problem:** Gesperrtes Root-Konto

```Bash
sudo passwd -u root
```

**Problem:** Vergessenes Passwort

```Bash
sudo passwd username
```

## Best Practices für das Troubleshooting

##### Systematische Fehlersuche

**Checkliste für Passwort-Probleme:**

```Markdown
┌─────────── Konfiguration ─────────────┐
│ □ PAM-Module installiert?             │
│ □ Konfigurationsdateien lesbar?       │
│ □ Berechtigungen korrekt?             │
├─────────── Logs ──────────────────────┤
│ □ auth.log überprüft?                 │
│ □ syslog kontrolliert?                │
│ □ systemd-journal geprüft?            │
├─────────── Benutzer ──────────────────┤
│ □ Account nicht gesperrt?             │
│ □ Gruppen korrekt?                    │
│ □ Shadow-Eintrag vorhanden?           │
└───────────────────────────────────────┘
```

**Logging und Monitoring**

```Bash
# Echtzeit-Log-Überwachung
sudo tail -f /var/log/auth.log

# Fehlgeschlagene Anmeldeversuche
sudo grep "Failed password" /var/log/auth.log

# PAM-Ereignisse überwachen
sudo journalctl -u systemd-logind
```

**Notfall-Wiederherstellung**

```Bash
# Temporäre Policy-Deaktivierung (nur im Notfall!)
sudo mv /etc/pam.d/common-password /etc/pam.d/common-password.bak
sudo cp /etc/pam.d/common-password.orig /etc/pam.d/common-password

# Backup wiederherstellen
sudo mv /etc/pam.d/common-password.bak /etc/pam.d/common-password
```

**Dokumentation und Reporting**

```Bash
# Aktuelle Konfiguration dokumentieren
sudo cp /etc/security/pwquality.conf /root/pwquality.conf.$(date +%F)

# Konfigurationsänderungen protokollieren
echo "$(date): PAM-Konfiguration angepasst" >> /var/log/security-changes.log

# Regelmäßige Überprüfungen
sudo aureport --auth    # Authentifizierungsberichte
sudo aureport --failed  # Fehlgeschlagene Anmeldungen
```

## Übung

##### Sichere Benutzerumgebung einrichten

**Szenario:** Du sollst für ein Entwicklungsteam eine sichere Benutzerumgebung mit fortgeschrittenen Passwort-Policies und Zugriffskontrollen einrichten.

**Anforderungen:**

```Markdown
┌─────────── Passwort-Policy ────────────┐
│ - Mindestens 12 Zeichen                │
│ - Komplexitätsregeln                   │
│ - 90 Tage Gültigkeit                   │
│ - 5 Passwörter Historie                │
├─────────── Benutzergruppen ────────────┤
│ - Entwickler (voller Zugriff)          │
│ - Praktikanten (eingeschränkt)         │
│ - Externe (temporärer Zugriff)         │
└────────────────────────────────────────┘
```

**Mögliche Lösung:**

```Bash
#!/bin/bash

# 1. PAM-Konfiguration
sudo nano /etc/security/pwquality.conf
# Füge hinzu:
minlen = 12
minclass = 3
maxrepeat = 2
enforce_for_root

# 2. Passwort-Historie
sudo nano /etc/pam.d/common-password
# Füge hinzu:
password required pam_pwhistory.so remember=5 use_authtok

# 3. Passwort-Aging
sudo nano /etc/login.defs
# Setze:
PASS_MAX_DAYS   90
PASS_MIN_DAYS   1
PASS_WARN_AGE   14

# 4. Gruppen erstellen
sudo groupadd entwickler
sudo groupadd praktikanten
sudo groupadd externe

# 5. Benutzer anlegen
# Entwickler
sudo useradd -m -s /bin/bash -G entwickler dev1
sudo chage -M 90 -m 1 -W 14 dev1

# Praktikant
sudo useradd -m -s /bin/bash -G praktikanten praktikant1
sudo chage -M 30 -m 1 -W 7 praktikant1

# Externer
sudo useradd -m -s /bin/bash -G externe extern1
sudo chage -E $(date -d "+90 days" +%Y-%m-%d) extern1
```

**Überprüfung:**

```Markdown
Checkliste:
┌─────────── Passwort-Policy ────────────┐
│ □ PAM-Module installiert               │
│ □ Komplexitätsregeln aktiv             │
│ □ Historie konfiguriert                │
├─────────── Benutzer ───────────────────┤
│ □ Entwickler-Accounts aktiv            │
│ □ Praktikanten zeitlich begrenzt       │
│ □ Externe mit Ablaufdatum              │
└────────────────────────────────────────┘
```

## Fazit

**Die fortgeschrittene Benutzerverwaltung in Linux geht weit über das einfache Anlegen und Löschen von Benutzerkonten hinaus.** In diesem Artikel haben wir uns mit den erweiterten Aspekten der Benutzerverwaltung beschäftigt, von der PAM-Konfiguration über Benutzerquotas bis hin zu ACLs und der Überwachung von Benutzeraktivitäten.

Wir haben gelernt, wie man sichere Passwort-Policies implementiert, Ressourcen durch Quotas begrenzt und feingranulare Zugriffsrechte mit ACLs verwaltet. Die Überwachung von Benutzeraktivitäten hilft uns dabei, die Sicherheit und Performance unseres Systems im Auge zu behalten.

Diese Werkzeuge und Konzepte bilden das Fundament für eine professionelle Systemadministration und sind besonders in Mehrbenutzerumgebungen und größeren Organisationen unverzichtbar.

Im nächsten Artikel unserer Serie werden wir uns mit <span class="badge-inline">[Prozessen und Ressourcenverwaltung](/de/linux-administration/linux-administration-prozesse-und-ressourcenverwaltung)</span> beschäftigen. Du lernst, wie Prozesse funktionieren, wie du sie überwachst und steuerst, und wie du Systemressourcen effizient verwaltest. Wir werden auch behandeln, wie du Performance-Probleme erkennst und behebst.

**Bis dahin, happy administrating!**