Linux Administration #7: Systemsicherheit und Härtung

Linux Administration #7: Systemsicherheit und Härtung
Navigation

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

Nachdem wir in den vorherigen Artikeln die Grundlagen, Benutzerverwaltung, Prozesse, Netzwerkkonfiguration, Shell-Scripting und Backup-Strategien behandelt haben, widmen wir uns heute der Systemsicherheit und Härtung deines Linux-Systems.

Die Sicherheit eines Linux-Systems ist eine der wichtigsten Aufgaben eines Administrators. In einer Zeit, in der Cyberangriffe zunehmen und Datenschutz immer wichtiger wird, musst du als Linux-Administrator wissen, wie du deine Systeme effektiv schützt. Dieser Artikel führt dich Schritt für Schritt durch die wichtigsten Aspekte der Systemsicherheit und zeigt dir, wie du dein System systematisch härtest.

Hinweis: 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.

Grundlegende Sicherheitskonzepte

Die Sicherheit eines Linux-Systems basiert auf mehreren fundamentalen Konzepten, die du als Administrator verstehen und umsetzen musst. Diese Konzepte bilden das Fundament für ein sicheres System.

1. Zugriffskontrolle

Die Zugriffskontrolle regelt, wer was auf deinem System tun darf.

Markdown
Zugriffskontroll-Komponenten:
┌─────────── Authentifizierung ──────┐
│ - Benutzeridentifikation           │
│ - Passwort-Policies                │
│ - Multi-Faktor-Authentifizierung   │
├─────────── Autorisierung ──────────┤
│ - Berechtigungen                   │
│ - Privilegien                      │
│ - Ressourcenzugriff                │
├─────────── Protokollierung ────────┤
│ - Audit-Logs                       │
│ - Aktivitätsüberwachung            │
│ - Sicherheitswarnungen             │
└────────────────────────────────────┘

Authentifizierung:

  • Identifiziert Benutzer eindeutig
  • Überprüft Zugangsdaten
  • Verhindert unbefugten Zugriff

Autorisierung:

  • Bestimmt Zugriffsrechte
  • Kontrolliert Ressourcenzugriff
  • Verwaltet Privilegien

Protokollierung:

  • Zeichnet Systemaktivitäten auf
  • Ermöglicht Nachverfolgung von Ereignissen
  • Unterstützt bei der Fehleranalyse
Markdown
Protokollierungs-Komponenten:
┌─────────── System-Logs ────────────┐
│ - Systemereignisse                 │
│ - Sicherheitsvorfälle              │
│ - Zugriffsprotokolle               │
├─────────── Audit-Logs ─────────────┤
│ - Benutzeraktivitäten              │
│ - Ressourcenzugriffe               │
│ - Konfigurationsänderungen         │
└────────────────────────────────────┘
2. Systemsicherheit

Ein sicheres System basiert auf mehreren Schutzschichten. Als Linux-Administrator musst du verstehen, wie diese Schichten zusammenarbeiten.

Markdown
Systemsicherheits-Komponenten:
┌─────────── Systemhärtung ───────────┐
│ - Aktuelle Software                 │
│ - Sichere Konfiguration             │
│ - Minimale Dienste                  │
├─────────── Zugriffskontrolle ───────┤
│ - Benutzerrechte                    │
│ - Firewall-Regeln                   │
│ - Netzwerkzugriff                   │
├─────────── Überwachung ─────────────┤
│ - System-Logging                    │
│ - Monitoring                        │
│ - Warnmeldungen                     │
└─────────────────────────────────────┘

Wichtige Aspekte der Systemsicherheit:

  1. Aktuelle Software
    • Regelmäßige Systemupdates
    • Sicherheitspatches installieren
    • Veraltete Software entfernen
  2. Minimale Angriffsfläche
    • Nur benötigte Dienste aktivieren
    • Offene Ports beschränken
    • Unnötige Software entfernen
  3. Sichere Konfiguration
    • Standard-Einstellungen überprüfen
    • Sichere Protokolle verwenden
    • Standardpasswörter ändern
3. Datensicherheit

Die Datensicherheit ist ein wichtiger Aspekt der Systemsicherheit. Sie umfasst den Schutz von Daten vor unbefugtem Zugriff, Verlust oder Manipulation.

Markdown
Datensicherheits-Aspekte:
┌─────────── Datenschutz ────────────┐
│ - Verschlüsselung                  │
│ - Zugriffskontrollen               │
│ - Berechtigungen                   │
├─────────── Datenverfügbarkeit ─────┤
│ - Backup-Strategien                │
│ - RAID-Systeme                     │
│ - Redundanz                        │
├─────────── Datenintegrität ────────┤
│ - Checksummen                      │
│ - Audit-Trails                     │
│ - Versionierung                    │
└────────────────────────────────────┘

Wichtige Aspekte der Datensicherheit:

  1. Datenschutz
    • Sensible Daten identifizieren und klassifizieren
    • Zugriff nur für autorisierte Benutzer
    • Verschlüsselung wichtiger Daten
  2. Datenverfügbarkeit
    • Regelmäßige Backups durchführen
    • Redundante Systeme einrichten
    • Disaster-Recovery-Plan erstellen
  3. Datenintegrität
    • Regelmäßige Integritätsprüfungen
    • Änderungsprotokolle führen
    • Versionskontrolle einsetzen

Bedrohungsszenarien

Als Linux-Administrator musst du verschiedene Arten von Bedrohungen kennen und verstehen, um dein System effektiv schützen zu können.

Markdown
Bedrohungsarten:
┌─────────── Externe Bedrohungen ──────┐
│ - Hacker-Angriffe                    │
│ - Malware und Viren                  │
│ - DDoS-Attacken                      │
├─────────── Interne Bedrohungen ──────┤
│ - Fehlkonfigurationen                │
│ - Unbeabsichtigte Fehler             │
│ - Missbrauch von Privilegien         │
├─────────── Systembedrohungen ────────┤
│ - Veraltete Software                 │
│ - Schwache Passwörter                │
│ - Offene Ports                       │
└──────────────────────────────────────┘
1. Externe Bedrohungen

Die häufigsten Angriffe von außen sind:

a) Brute-Force-Angriffe

  • Wiederholte Anmeldeversuche
  • Ziel: Passwörter knacken
  • Besonders häufig bei SSH-Diensten

b) Malware und Ransomware

  • Schadsoftware auf Servern
  • Verschlüsselung von Daten
  • Diebstahl sensibler Informationen

c) DDoS-Attacken

  • Überlastung von Diensten
  • Serverausfall durch massive Anfragen
  • Netzwerkressourcen erschöpfen
2. Interne Bedrohungen

Interne Bedrohungen entstehen oft unbeabsichtigt durch Fehlkonfigurationen oder Benutzerfehler.

a) Fehlkonfigurationen

  • Falsch gesetzte Berechtigungen
  • Unsichere Standard-Einstellungen
  • Veraltete Konfigurationsdateien

b) Benutzerfehler

  • Versehentliches Löschen wichtiger Dateien
  • Unbeabsichtigtes Ändern von Systemeinstellungen
  • Falsche Handhabung sensibler Daten

c) Missbrauch von Privilegien

  • Unbefugte Nutzung von Root-Rechten
  • Zugriff auf nicht autorisierte Ressourcen
  • Installation nicht genehmigter Software
Markdown
Interne Risikofaktoren:
┌─────────── Konfiguration ──────────┐
│ - Falsche Berechtigungen           │
│ - Unsichere Standardeinstellungen  │
│ - Veraltete Software               │
├─────────── Benutzer ───────────────┤
│ - Fehlbedienungen                  │
│ - Mangelndes Sicherheitswissen     │
│ - Unachtsamkeit                    │
└────────────────────────────────────┘
3. Systembedrohungen

Systembedrohungen entstehen oft durch Schwachstellen in der Konfiguration oder veraltete Software.

Markdown
Systembedrohungen:
┌─────────── Software ──────────────┐
│ - Veraltete Versionen             │
│ - Bekannte Schwachstellen         │
│ - Unsichere Konfigurationen       │
├─────────── Dienste ───────────────┤
│ - Offene Ports                    │
│ - Unsichere Protokolle            │
│ - Unnötige Services               │
├─────────── Zugänge ───────────────┤
│ - Schwache Passwörter             │
│ - Standard-Konten                 │
│ - Offene Netzwerkdienste          │
└───────────────────────────────────┘

a) Software-Schwachstellen

  • Nicht aktualisierte Systeme
  • Bekannte Sicherheitslücken
  • Fehlende Sicherheitspatches

b) Dienste und Ports

  • Unnötig laufende Dienste
  • Standardmäßig offene Ports
  • Unsichere Protokollversionen

c) Zugriffsschwachstellen

  • Standard-Benutzerkonten
  • Schwache Passwort-Policies
  • Fehlende Zugriffsbeschränkungen

Grundlegende Systemhärtung

Die Systemhärtung ist der erste und wichtigste Schritt zur Absicherung deines Linux-Systems. Dabei geht es darum, potenzielle Schwachstellen zu minimieren und das System widerstandsfähiger gegen Angriffe zu machen.

Markdown
Härtungs-Komponenten:
┌─────────── Zugangskontrolle ────────┐
│ - Benutzerrechte                    │
│ - Passwort-Policies                 │
│ - SSH-Konfiguration                 │
├─────────── System-Basis ────────────┤
│ - Dienste-Minimierung               │
│ - Port-Absicherung                  │
│ - Update-Management                 │
└─────────────────────────────────────┘
1. Benutzer und Berechtigungen

a) Benutzerkonten überprüfen:

Bash
# Aktive Benutzer anzeigen
awk -F: '$3 >= 1000 && $7 != "/sbin/nologin" {print $1}' /etc/passwd

# Benutzer ohne Passwort finden
sudo awk -F: '($2 == "") {print $1}' /etc/shadow

# Überflüssige Systemkonten deaktivieren
sudo usermod -s /sbin/nologin unnötiger_benutzer

b) Access Control Lists (ACLs)

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

# ACL-Regel hinzufügen
setfacl -m u:benutzer:rw- datei.txt
setfacl -m g:gruppe:r-- datei.txt

c) Umask-Einstellungen

Bash
# Aktuelle Umask anzeigen
umask

# Umask systemweit setzen (in /etc/profile)
umask 022  # Standardwert für mehr Sicherheit
2. Passwort-Policies

Eine starke Passwort-Policy ist fundamental für die Systemsicherheit. Als Administrator musst du sicherstellen, dass alle Benutzer sichere Passwörter verwenden.

Markdown
Passwort-Komponenten:
┌─────────── Komplexität ───────────┐
│ - Mindestlänge                    │
│ - Zeichenarten                    │
│ - Wiederholungen                  │
├─────────── Gültigkeit ────────────┤
│ - Maximales Alter                 │
│ - Änderungsintervall              │
│ - Historie                        │
└───────────────────────────────────┘

a) Passwort-Anforderungen konfigurieren

Bash
# PAM-Modul für Passwort-Qualität installieren
sudo apt install libpam-pwquality

# Konfigurationsdatei bearbeiten
sudo nano /etc/security/pwquality.conf

# Wichtige Einstellungen:
minlen = 12          # Minimale Passwortlänge
minclass = 3         # Mindestanzahl verschiedener Zeichenklassen
maxrepeat = 2        # Maximale Zeichenwiederholungen

b) Passwort-Alterung einrichten

Bash
# Passwort-Alterung konfigurieren
sudo chage -M 90 -m 7 -W 14 benutzer
# -M: maximales Alter (90 Tage)
# -m: minimales Alter (7 Tage)
# -W: Warnzeit (14 Tage vor Ablauf)

c) Account Lockout

Bash
# In /etc/pam.d/common-auth
auth required pam_tally2.so deny=5 unlock_time=1800
# Nach 5 Fehlversuchen, 30 Minuten Sperre

d) Passwort-Historie

Bash
# In /etc/pam.d/common-auth
auth required pam_tally2.so deny=5 unlock_time=1800
# Nach 5 Fehlversuchen, 30 Minuten Sperre
3. Dienste und offene Ports

Als Linux-Administrator ist es wichtig, nur die wirklich benötigten Dienste laufen zu lassen. Jeder aktive Dienst kann eine potenzielle Schwachstelle darstellen.

Markdown
Dienst-Management:
┌─────────── Analyse ─────────────┐
│ - Laufende Dienste              │
│ - Offene Ports                  │
│ - Abhängigkeiten                │
├─────────── Optimierung ─────────┤
│ - Unnötige Dienste stoppen      │
│ - Ports schließen               │
│ - Autostart deaktivieren        │
└─────────────────────────────────┘

a) Laufende Dienste identifizieren:

Bash
# Aktive Dienste anzeigen
systemctl list-units --type=service --state=running

# Offene Ports überprüfen
ss -tulpn

b) Unnötige Dienste deaktivieren:

Bash
# Dienst stoppen und deaktivieren
sudo systemctl stop [dienst]
sudo systemctl disable [dienst]

# Status überprüfen
sudo systemctl status [dienst]

Häufig deaktivierte Dienste:

  • Druckdienst (cups) wenn kein Drucker verwendet wird
  • Bluetooth-Dienst auf Servern
  • Telnet (unsicher, SSH verwenden)
  • Nicht benötigte Datenbank-Dienste

c) Ports und Netzwerkdienste überwachen:

Bash
# Offene Ports und zugehörige Dienste anzeigen
netstat -tulpn

# Alternative mit ss (moderne Version)
ss -tulpn

# Spezifischen Port überprüfen
lsof -i :80

d) Dienste absichern:

Bash
# Dienst-Konfiguration prüfen
systemctl show [dienst]

# Dienst auf bestimmte IP beschränken
# In der jeweiligen Dienst-Konfiguration:
Listen 127.0.0.1:port   # Nur lokaler Zugriff
4. Systemaktualisierungen

Regelmäßige Systemaktualisierungen sind essentiell für die Sicherheit deines Linux-Systems. Sie schließen bekannte Sicherheitslücken und verbessern die Systemstabilität.

Markdown
Update-Komponenten:
┌─────────── Paketquellen ──────────┐
│ - Repository-Listen               │
│ - Signatur-Prüfung                │
│ - Mirror-Auswahl                  │
├─────────── Updates ───────────────┤
│ - Sicherheitsupdates              │
│ - Systemupdates                   │
│ - Anwendungsupdates               │
└───────────────────────────────────┘

a) Update-Prozess

  1. Paketquellen aktualisieren
  2. Verfügbare Updates prüfen
  3. Updates installieren
  4. System neu starten (wenn nötig)

b) Best Practices für Updates:

  • Regelmäßige Update-Zeitpläne erstellen
  • Wichtige Systeme vorher testen
  • Backup vor größeren Updates
  • Update-Logs überprüfen

c) Automatische Updates konfigurieren:

Bash
# Unattended-upgrades installieren
sudo apt install unattended-upgrades

# Automatische Updates aktivieren
sudo dpkg-reconfigure unattended-upgrades

# Konfiguration anpassen
sudo nano /etc/apt/apt.conf.d/50unattended-upgrades

d) Repository-Management und Sicherheit

Bash
# Repository-Listen prüfen
ls -l /etc/apt/sources.list.d/

# Signaturschlüssel verwalten
apt-key list

e) Update-Logging und Monitoring:

Bash
# Update-Logs prüfen
less /var/log/apt/history.log
less /var/log/dpkg.log

# Automatische Update-Benachrichtigungen
sudo apt install apticron
sudo nano /etc/apticron/apticron.conf

e) Rollback-Strategien:

Bash
# Snapshot vor Update erstellen (wenn LVM verwendet wird)
sudo lvcreate -s -n backup-snap -L 1G /dev/vg0/root

# Paketversionen auflisten
apt-cache policy paketname

# Spezifische Version installieren
sudo apt install paketname=versionsnummer

Wichtige Best Practices:

  1. Vor großen Updates immer Backup erstellen
  2. Updates zuerst in Testumgebung testen
  3. Update-Logs regelmäßig prüfen
  4. Rollback-Plan bereithalten

Netzwerksicherheit

Die Absicherung deines Netzwerks ist eine der wichtigsten Aufgaben in der Systemsicherheit. Lass uns die verschiedenen Aspekte der Netzwerksicherheit systematisch durchgehen.

Markdown
Netzwerksicherheits-Komponenten:
┌─────────── Firewall ─────────────┐
│ - Regelbasierte Filterung        │
│ - Port-Kontrolle                 │
│ - Zugriffskontrolle              │
├─────────── SSH-Sicherheit ───────┤
│ - Schlüssel-Authentifizierung    │
│ - Port-Änderung                  │
│ - Zugriffsbeschränkungen         │
├─────────── Überwachung ──────────┤
│ - Port-Scanning                  │
│ - Traffic-Monitoring             │
│ - Intrusion Detection            │
└──────────────────────────────────┘
1. Firewall-Konfiguration

Die Firewall ist deine erste Verteidigungslinie gegen unerwünschte Netzwerkzugriffe. Linux bietet dafür verschiedene Firewall-Lösungen an, die sich in ihrer Komplexität und ihren Möglichkeiten unterscheiden.

a) UFW (Uncomplicated Firewall)

Bash
# UFW aktivieren
sudo ufw enable

# Standardregeln setzen
sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH-Zugriff erlauben
sudo ufw allow ssh

b) IPTables

Bash
# Grundlegende Regeln
sudo iptables -A INPUT -i lo -j ACCEPT
sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# Standardpolicy setzen
sudo iptables -P INPUT DROP

c) nftables

Bash
# Basis-Konfiguration
nft add table inet filter
nft add chain inet filter input { type filter hook input priority 0 \; }
nft add rule inet filter input ct state established,related accept
nft add rule inet filter input tcp dport 22 accept
2. SSH-Absicherung

Die sichere Konfiguration von SSH ist essentiell für die Systemsicherheit. Hier sind die wichtigsten Maßnahmen:

a) Grundlegende SSH-Konfiguration

Bash
sudo nano /etc/ssh/sshd_config
TypeScript
# Wichtige Sicherheitseinstellungen
Port 2222                  # Standard-Port ändern
PermitRootLogin no         # Root-Login verbieten
MaxAuthTries 3             # Maximale Anmeldeversuche
LoginGraceTime 20          # Zeitlimit für Login
PasswordAuthentication no  # Passwort-Auth deaktivieren

b) Zugriffsbeschränkungen

TypeScript
# Nur bestimmte Benutzer erlauben
AllowUsers admin maintainer

# Nur bestimmte Gruppen erlauben
AllowGroups ssh-users admins

# SSH-Protokoll Version 2 erzwingen
Protocol 2

c) Schlüsselbasierte Authentifizierung

Bash
# Schlüsselpaar erstellen
ssh-keygen -t rsa -b 4096

# Öffentlichen Schlüssel auf Server kopieren
ssh-copy-id -i ~/.ssh/id_rsa.pub benutzer@server

d) Fail2ban Konfiguration

Bash
sudo apt install fail2ban

Konfiguration anpassen:

Bash
# Konfiguration anpassen
sudo nano /etc/fail2ban/jail.local

# Beispielkonfiguration für SSH
[sshd]
enabled = true
port = 2222
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600

e) SSH-Protokoll und Cipher

Bash
# In /etc/ssh/sshd_config
# Nur sichere Protokolle erlauben
Protocol 2

# Starke Verschlüsselung erzwingen
Ciphers aes256-ctr,aes192-ctr,aes128-ctr
MACs hmac-sha2-512,hmac-sha2-256

f) SSH-Timeouts

Bash
# In /etc/ssh/sshd_config
# Verbindungszeitlimits setzen
ClientAliveInterval 300
ClientAliveCountMax 2
LoginGraceTime 30

g) X11-Forwarding und TCP-Forwarding

Bash
# X11-Forwarding deaktivieren
X11Forwarding no

# TCP-Forwarding einschränken
AllowTcpForwarding no
3. Port-Scanning und Monitoring

Port-Scanning ist ein wichtiges Werkzeug für Systemadministratoren, um potenzielle Sicherheitslücken zu identifizieren

Markdown
Port-Scanning-Komponenten:
┌─────────── Scanning-Arten ─────────┐
│ - TCP-Scans                        │
│ - UDP-Scans                        │
│ - Service-Detection                │
├─────────── Monitoring ─────────────┤
│ - Echtzeit-Überwachung             │
│ - Log-Analyse                      │
│ - Anomalie-Erkennung               │
└────────────────────────────────────┘

a) Port-Scanning mit nmap

Bash
# Grundlegender Scan
nmap -sV localhost

# Detaillierter Scan mit Service-Erkennung
nmap -sS -sV -p1-65535 192.168.1.1

# Schneller Scan für offene Ports
nmap -F 192.168.1.0/24
Rechtliche Aspekte
  • Scanne nur Systeme, für die du autorisiert bist
  • Dokumentiere alle Scanning-Aktivitäten
  • Beachte Datenschutzrichtlinien und Compliance-Anforderungen
Best Practices
  • Regelmäßige Scans durchführen
  • Ergebnisse dokumentieren und analysieren
  • Auffälligkeiten sofort nachgehen
  • Scanning-Aktivitäten in ruhigen Zeiten durchführen

d) Monitoring-Tools

Bash
# Echtzeit-Netzwerk-Monitoring
sudo tcpdump -i eth0

# Prozess-Monitoring
htop
netstat -tulpn

# Systemüberwachung
vmstat 1
iostat -x 1

e) Traffic-Analyse

Bash
# Wireshark (GUI)
sudo apt install wireshark

# Alternative: tshark (CLI)
tshark -i eth0 -f "port 80"
4. Intrusion Detection

Ein Intrusion Detection System (IDS) ist wie ein Sicherheitssystem für dein Haus – es überwacht alle Aktivitäten und meldet verdächtige Vorfälle. Als Linux-Administrator solltest du verstehen, wie diese Systeme funktionieren und wie du sie effektiv einsetzt.

Markdown
IDS-Komponenten:
┌─────────── Erkennung ─────────────┐
│ - Log-Analyse                     │
│ - Netzwerk-Überwachung            │
│ - Verhaltensanalyse               │
├─────────── Reaktion ──────────────┤
│ - Warnmeldungen                   │
│ - Automatische Blockierung        │
│ - Incident Response               │
└───────────────────────────────────┘

a) Host-basierte IDS (HIDS)
Ein HIDS überwacht direkt deinen Server oder Computer:

  • Überprüft Systemdateien auf unerwartete Änderungen
  • Überwacht wichtige Konfigurationsdateien
  • Erkennt ungewöhnliche Benutzeraktivitäten

Beispiel mit AIDE:

Bash
# AIDE installieren
sudo apt install aide

# Erste Datenbank erstellen
sudo aide --init

# System auf Änderungen prüfen
sudo aide --check

b) Netzwerk-basierte IDS (NIDS)
Ein NIDS ist wie eine Überwachungskamera für dein Netzwerk:

  • Analysiert den gesamten Netzwerkverkehr
  • Erkennt verdächtige Verbindungsversuche
  • Meldet ungewöhnliche Aktivitäten

Beispiel mit Snort:

Bash
# Snort installieren
sudo apt install snort

# Grundlegende Konfiguration
sudo nano /etc/snort/snort.conf

# Snort im IDS-Modus starten
sudo snort -q -l /var/log/snort -i eth0

c) Praktische Implementierung für Einsteiger

Log-Überwachung einrichten:

Bash
# Wichtige Log-Dateien regelmäßig prüfen
tail -f /var/log/auth.log    # Authentifizierungsversuche
tail -f /var/log/syslog      # Systemereignisse
tail -f /var/log/apache2/error.log  # Webserver-Fehler

Automatische Benachrichtigungen:

Bash
# E-Mail-Benachrichtigung bei verdächtigen Aktivitäten
sudo apt install logwatch
sudo nano /etc/logwatch/conf/logwatch.conf

Regelmäßige Systemprüfungen:

Bash
# Rootkit-Scanner installieren und ausführen
sudo apt install rkhunter
sudo rkhunter --check

# Systemdateien auf Änderungen prüfen
sudo aide --check
Best Practices zur Netzwerksicherheit

Als Linux-Administrator solltest du diese grundlegenden Sicherheitsmaßnahmen implementieren:

Markdown
Best Practices:
┌─────────── Grundsicherung ──────────┐
│ - Minimale offene Ports             │
│ - Starke SSH-Konfiguration          │
│ - Regelmäßige Updates               │
├─────────── Überwachung ─────────────┤
│ - Logging aktivieren                │
│ - Monitoring einrichten             │
│ - Regelmäßige Scans                 │
├─────────── Notfallplan ─────────────┤
│ - Backup-Strategie                  │
│ - Incident Response                 │
│ - Dokumentation                     │
└─────────────────────────────────────┘

1. Grundlegende Sicherheitsmaßnahmen:

  • Nur notwendige Dienste aktivieren
  • Regelmäßige Sicherheitsupdates
  • Starke Passwort-Policies
  • Zwei-Faktor-Authentifizierung wo möglich

2. Firewall-Best-Practices:

  • Standard-Policy: „Deny All„
  • Nur benötigte Ports öffnen
  • Zugriff auf vertrauenswürdige IPs beschränken
  • Logging für wichtige Regeln aktivieren

3. SSH-Absicherung:

  • Schlüsselbasierte Authentifizierung
  • Root-Login deaktivieren
  • Nicht-Standard-Port verwenden
  • Zugriff auf bestimmte Benutzer beschränken

4. Monitoring-Best-Practices:

  • Regelmäßige Systemüberwachung
  • Protokollierung wichtiger Ereignisse
  • Automatische Benachrichtigungen
Markdown
Monitoring-Komponenten:
┌─────────── System-Monitoring ─────────┐
│ - Ressourcenauslastung                │
│ - Dienste-Status                      │
│ - Performance-Metriken                │
├─────────── Sicherheits-Monitoring ────┤
│ - Login-Versuche                      │
│ - Firewall-Logs                       │
│ - Verdächtige Aktivitäten             │
├─────────── Protokollierung ───────────┤
│ - Zentrale Log-Sammlung               │
│ - Log-Rotation                        │
│ - Backup der Logs                     │
└───────────────────────────────────────┘

5. Implementierungs-Checkliste:

  • Firewall-Regeln regelmäßig überprüfen
  • SSH-Zugriff absichern
  • Ports und Dienste überwachen
  • IDS/IPS-System einrichten
  • Backup-Strategie implementieren
  • Notfallplan dokumentieren

6. Regelmäßige Wartung:

  • Updates einspielen
  • Logs analysieren
  • Berechtigungen prüfen
  • Sicherheits-Audits durchführen
  • Dokumentation aktualisieren

Zugriffskontrolle

Zugriffskontrolle ist ein zentraler Aspekt der Systemsicherheit in Linux. Sie regelt, wer auf welche Ressourcen zugreifen darf und wie dieser Zugriff erfolgt.

Markdown
Zugriffskontroll-Komponenten:
┌─────────── Berechtigungen ──────────┐
│ - Dateisystemrechte                 │
│ - ACLs (Access Control Lists)       │
│ - SELinux / AppArmor                │
├─────────── Authentifizierung ───────┤
│ - Benutzer- und Gruppenmanagement   │
│ - PAM (Pluggable Auth Modules)      │
│ - Sudo-Konfiguration                │
├─────────── Überwachung ─────────────┤
│ - Logging                           │
│ - Audit                             │
│ - Intrusion Detection               │
└─────────────────────────────────────┘
1. SELinux/AppArmor

Als Linux-Administrator hast du die Wahl zwischen zwei wichtigen Mandatory Access Control (MAC) Systemen: SELinux und AppArmor. Beide bieten zusätzliche Sicherheitsebenen über die normalen Linux-Berechtigungen hinaus.

Markdown
MAC-Systeme Vergleich:
┌─────────── SELinux ───────────────┐
│ - Komplexer und mächtiger         │
│ - Label-basierte Kontrolle        │
│ - Standard in RHEL/Fedora         │
├─────────── AppArmor ──────────────┤
│ - Einfacher zu konfigurieren      │
│ - Pfad-basierte Kontrolle         │
│ - Standard in Ubuntu/SUSE         │
└───────────────────────────────────┘

a) SELinux

  • Bietet sehr granulare Kontrolle
  • Verwendet Sicherheitskontexte und Labels
  • Standardmäßig restriktiv („enforcing“)

Grundlegende SELinux-Verwaltung:

Bash
# Status prüfen
getenforce

# Modi wechseln
setenforce 0  # Permissive Mode
setenforce 1  # Enforcing Mode

# Kontext anzeigen
ls -Z /var/www/html/

b) AppArmor

  • Einfacher zu konfigurieren als SELinux
  • Verwendet pfadbasierte Kontrolle
  • Standard in Ubuntu und SUSE

Grundlegende AppArmor-Verwaltung:

Bash
# Status prüfen
sudo aa-status

# Profile anzeigen
sudo aa-enabled

# Profil-Status prüfen
sudo aa-enforce /etc/apparmor.d/usr.sbin.mysqld  # Enforcing Mode
sudo aa-complain /etc/apparmor.d/usr.sbin.mysqld # Permissive Mode

AppArmor Profile verstehen:

  • Profile definieren erlaubte Aktionen
  • Beschränken Zugriff auf Dateien und Ressourcen
  • Können im complain oder enforce Modus laufen
TypeScript
# Beispiel eines einfachen AppArmor Profils
# /etc/apparmor.d/usr.bin.beispiel
/usr/bin/beispiel {
  /etc/beispiel.conf r,    # Nur Lesen erlaubt
  /var/log/beispiel.log w, # Nur Schreiben erlaubt
  /tmp/** rwk,            # Voller Zugriff in /tmp
}
2. Access Control Lists (ACLs)

ACLs erweitern das traditionelle Linux-Berechtigungssystem. Während das Standard-Berechtigungssystem nur einen Besitzer und eine Gruppe pro Datei erlaubt, ermöglichen ACLs dir, Berechtigungen für mehrere Benutzer und Gruppen zu vergeben.

Markdown
ACL-Komponenten:
┌─────────── Benutzer-ACLs ───────────┐
│ - Spezifische Benutzerrechte        │
│ - Zusätzlich zu Standardrechten     │
├─────────── Gruppen-ACLs ────────────┤
│ - Spezifische Gruppenrechte         │
│ - Erweiterte Zugriffssteuerung      │
├─────────── Vererbung ───────────────┤
│ - Default-ACLs für Verzeichnisse    │
│ - Automatische Rechtevererbung      │
└─────────────────────────────────────┘

Warum sind ACLs wichtig?
Stell dir folgendes Szenario vor: Du hast eine Projektdatei, auf die verschiedene Teammitglieder unterschiedliche Zugriffsrechte benötigen:

  • Anna soll die Datei bearbeiten können
  • Bob soll sie nur lesen dürfen
  • Die Entwickler-Gruppe braucht Schreibrechte
  • Die Marketing-Gruppe nur Leserechte

Mit Standard-Berechtigungen wäre das nicht möglich, aber ACLs machen es einfach.

a) ACLs aktivieren und prüfen:

Bash
# Prüfen, ob Dateisystem ACLs unterstützt
tune2fs -l /dev/sda1 | grep "Default mount options"

# ACL-Unterstützung im Dateisystem aktivieren
sudo mount -o remount,acl /

# ACLs für eine Datei anzeigen
getfacl projekt.txt

b) ACLs setzen:

Bash
# Benutzer-ACL hinzufügen
setfacl -m u:anna:rw- projekt.txt    # Anna erhält Lese- und Schreibrechte
setfacl -m u:bob:r-- projekt.txt     # Bob erhält nur Leserechte

# Gruppen-ACL hinzufügen
setfacl -m g:entwickler:rw- projekt.txt  # Entwickler können lesen und schreiben
setfacl -m g:marketing:r-- projekt.txt   # Marketing kann nur lesen

Erweiterte ACL-Funktionen

ACLs bieten zusätzliche Möglichkeiten für komplexere Zugriffsszenarien:

a) Default-ACLs für Verzeichnisse

Bash
# Default-ACL setzen (wird von neuen Dateien geerbt)
setfacl -d -m g:projekt:rx /shared/projekt/

# Default-ACLs anzeigen
getfacl /shared/projekt/

b) Mehrfache ACL-Einträge

Bash
# Mehrere Berechtigungen in einem Befehl
setfacl -m u:anna:rx,u:bob:r,g:projekt:rwx datei.txt

# Spezifische ACLs entfernen
setfacl -x u:anna datei.txt

c) ACL-Backup und Wiederherstellung

Bash
# ACLs sichern
getfacl -R /shared/projekt/ > acl_backup.txt

# ACLs wiederherstellen
setfacl --restore=acl_backup.txt

d) ACL-Vererbung

Bash
# Rekursive ACL-Anwendung
setfacl -R -m g:projekt:rx /shared/projekt/

# Bestehende ACLs rekursiv entfernen
setfacl -R -b /shared/projekt/
3. Sudo-Konfiguration

Sudo (Superuser Do) ist ein wichtiges Sicherheitswerkzeug, das Benutzern erlaubt, bestimmte Befehle mit Root-Rechten auszuführen, ohne direkt als Root eingeloggt zu sein.

Markdown
Sudo-Komponenten:
┌─────────── Konfiguration ─────────┐
│ - /etc/sudoers                    │
│ - /etc/sudoers.d/                 │
│ - Benutzer-Richtlinien            │
├─────────── Berechtigungen ────────┤
│ - Befehle                         │
│ - Hosts                           │
│ - Benutzer/Gruppen                │
└───────────────────────────────────┘

a) Grundlegende Sudo-Konfiguration

Sudo-Konfiguration sicher bearbeiten

Bash
sudo visudo

Beispiel einer Sudo-Regel:

Markdown
anna ALL=(ALL:ALL) /usr/bin/apt
│    │   │   │     └── Erlaubter Befehl
│    │   │   └──────── Erlaubte Gruppen
│    │   └──────────── Erlaubte Benutzer
│    └──────────────── Erlaubte Hosts
└───────────────────── Benutzername

b) Häufige Sudo-Konfigurationen:

Bash
# Benutzer zur sudo-Gruppe hinzufügen
sudo usermod -aG sudo username

# Passwortlose Sudo-Rechte
username ALL=(ALL) NOPASSWD: ALL

# Spezifische Befehle erlauben
username ALL=(ALL) /usr/bin/apt, /usr/bin/systemctl

d) Sudo-Regeln im Detail

Bash
# Beispiele für spezifische Sudo-Regeln
# In /etc/sudoers oder /etc/sudoers.d/benutzer

# Nur bestimmte Befehle erlauben
anna ALL=(ALL) /usr/bin/apt update, /usr/bin/apt upgrade

# Ohne Passwort bestimmte Befehle ausführen
bob ALL=(ALL) NOPASSWD: /usr/bin/systemctl status *

# Zeitbeschränkung für Sudo-Sitzung
Defaults:charlie timestamp_timeout=10

e) Sudo-Sicherheit

Bash
# Sudo-Logs aktivieren
Defaults logfile="/var/log/sudo.log"

# Fehlgeschlagene Versuche protokollieren
Defaults!ALL logfile="/var/log/sudo_failed.log"

# Sudo-Timeout einstellen
Defaults passwd_timeout=1
Defaults timestamp_timeout=10

f) Sudo-Rechte im Detail

Bash
# In /etc/sudoers oder /etc/sudoers.d/benutzer

# Bestimmte Befehle erlauben
anna ALL=(ALL) /usr/bin/apt update, /usr/bin/apt upgrade

# Befehle ohne Passwort
bob ALL=(ALL) NOPASSWD: /usr/bin/systemctl status *

# Befehle für bestimmte Gruppen
%entwickler ALL=(ALL) /usr/bin/docker

g) Praktische Anwendungsfälle

  • System-Updates durchführen
  • Dienste verwalten
  • Log-Dateien einsehen
  • Netzwerk-Tools verwenden

h) Sicherheitsrichtlinien

  • Minimale Rechte vergeben
  • Sudo-Logs aktivieren
  • Regelmäßige Überprüfung der Rechte
  • Zeitbeschränkungen einsetzen
4. Logging und Audit

Das Logging- und Audit-System ist wie eine Überwachungskamera für dein Linux-System. Es zeichnet wichtige Ereignisse auf und hilft dir, Probleme zu erkennen und zu analysieren.

Systemprotokollierung verstehen:

  • Logs sind wie ein Tagebuch deines Systems
  • Jedes wichtige Ereignis wird protokolliert
  • Verschiedene Logs für verschiedene Zwecke
  • Zentrale Sammlung aller Informationen
Markdown
Log-Struktur:
┌─────────── System-Logs ───────────┐
│ /var/log/syslog                   │
│ /var/log/messages                 │
│ /var/log/kern.log                 │
├─────────── Security-Logs ─────────┤
│ /var/log/auth.log                 │
│ /var/log/secure                   │
│ /var/log/audit/audit.log          │
├─────────── Service-Logs ──────────┤
│ /var/log/apache2/                 │
│ /var/log/mysql/                   │  
│ /var/log/mail.log                 │
└───────────────────────────────────┘

Wichtige Log-Dateien im Detail:

  1. /var/log/auth.log (Debian/Ubuntu) oder /var/log/secure (RHEL/CentOS):
    • Authentifizierungsversuche
    • Sudo-Verwendung
    • SSH-Zugriffe
    • Passwortänderungen
  2. /var/log/syslog oder /var/log/messages:
    • Allgemeine Systemmeldungen
    • Dienststarts und -stops
    • Hardware-Ereignisse
    • Netzwerkaktivitäten

Praktische Log-Analyse

Wichtige Log-Dateien und ihre Bedeutung:

Bash
# Authentifizierungs-Logs
tail -f /var/log/auth.log

# Zeigt:
# - Login-Versuche
# - Sudo-Verwendung
# - SSH-Zugriffe
# - Passwortänderungen

# System-Logs
tail -f /var/log/syslog

# Zeigt:
# - Systemstarts/-stops
# - Dienst-Status
# - Hardware-Ereignisse
# - Kernel-Meldungen

Log-Analyse mit grundlegenden Tools:

Bash
# Suche nach fehlgeschlagenen Login-Versuchen
grep "Failed password" /var/log/auth.log

# Letzte SSH-Verbindungen anzeigen
grep "Accepted" /var/log/auth.log

# Systemstarts anzeigen
grep "Startup finished" /var/log/syslog

Log-Rotation verstehen:

Bash
# Log-Rotation-Status prüfen
ls -l /var/log/auth.log*

# Zeigt:
# auth.log        # Aktuelle Log-Datei
# auth.log.1      # Letzte Log-Datei
# auth.log.2.gz   # Ältere, komprimierte Logs

Verschlüsselung

Die Verschlüsselung ist wie ein Tresor für deine Daten – sie stellt sicher, dass nur autorisierte Personen mit dem richtigen „Schlüssel“ auf die Informationen zugreifen können. Als Linux-Administrator musst du verschiedene Verschlüsselungsmethoden kennen und einsetzen können.

Markdown
Verschlüsselungs-Ebenen:
┌─────────── Daten in Ruhe ─────────┐
│ - Festplattenverschlüsselung      │
│ - Dateisystemverschlüsselung      │
│ - Container-Verschlüsselung       │
├─────────── Daten in Bewegung ─────┤
│ - SSL/TLS                         │
│ - SSH                             │
│ - VPN                             │
├─────────── Schlüsselverwaltung ───┤
│ - Zertifikate                     │
│ - Private/Public Keys             │
│ - Passwort-Safes                  │
└───────────────────────────────────┘
1. Festplattenverschlüsselung

Die Festplattenverschlüsselung ist die erste Verteidigungslinie zum Schutz deiner Daten. Sie verschlüsselt alle Daten auf der Festplatte, sodass sie ohne den richtigen Schlüssel nicht lesbar sind.

Markdown
Verschlüsselungs-Arten:
┌─────────── Full-Disk ───────────┐
│ - Komplette Festplatte          │
│ - Inkl. Systemdateien           │
│ - LUKS/dm-crypt                 │
├─────────── Partition ───────────┤
│ - Einzelne Partitionen          │
│ - Datenbereiche                 │
│ - Flexibel erweiterbar          │
└─────────────────────────────────┘

a) LUKS (Linux Unified Key Setup)
LUKS ist der Linux-Standard für Festplattenverschlüsselung. Es bietet:

  • Sichere Schlüsselverwaltung
  • Mehrere Passwörter pro Partition
  • Kompatibilität mit allen Linux-Distributionen

b) Neue verschlüsselte Partition erstellen:

Bash
# Partition vorbereiten
sudo cryptsetup luksFormat /dev/sdb1

# Partition öffnen
sudo cryptsetup luksOpen /dev/sdb1 secure_data

# Dateisystem erstellen
sudo mkfs.ext4 /dev/mapper/secure_data

# Partition einbinden
sudo mount /dev/mapper/secure_data /mnt/encrypted
2. Dateisystemverschlüsselung

Die Dateisystemverschlüsselung ermöglicht dir, einzelne Verzeichnisse oder Dateisysteme zu verschlüsseln, ohne die gesamte Festplatte zu verschlüsseln.

Markdown
Verschlüsselungs-Optionen:
┌─────────── eCryptfs ────────────┐
│ - Verzeichnisverschlüsselung    │
│ - Home-Verzeichnisse            │
│ - Pro-Benutzer                  │
├─────────── EncFS ───────────────┤
│ - FUSE-basiert                  │
│ - Transparent                   │
│ - Flexibel                      │
└─────────────────────────────────┘

a) eCryptfs für Home-Verzeichnisse

Bash
# eCryptfs Tools installieren
sudo apt install ecryptfs-utils

# Neues verschlüsseltes Home erstellen
sudo ecryptfs-migrate-home -u benutzer

# Nach der Migration
ecryptfs-unwrap-passphrase

# Speichere die Wiederherstellungsphrase sicher!

b) EncFS für flexible Verschlüsselung

Bash
# EncFS installieren
sudo apt install encfs

# Verschlüsseltes Verzeichnis erstellen
encfs ~/.private ~/Private

# Verzeichnis einbinden
# Wird nach Passwort fragen

Wichtige Hinweise:

  • Sichere Passwörter verwenden
  • Wiederherstellungsschlüssel sicher aufbewahren
  • Regelmäßige Backups der verschlüsselten Daten
  • Performance-Einbußen beachten
3. SSL/TLS-Konfiguration

SSL/TLS ist ein wichtiges Protokoll für die Verschlüsselung von Daten während der Übertragung. Es stellt sicher, dass sensible Informationen sicher zwischen zwei Punkten übertragen werden.

Grundlegende Komponenten

  • Zertifikate: Digitale Identitätsnachweise
  • Private Schlüssel: Geheime Schlüssel für die Entschlüsselung
  • Public Keys: Öffentliche Schlüssel für die Verschlüsselung

Verschlüsselungsstandards

  • TLS 1.2 und 1.3 sind die aktuell sicheren Versionen
  • Ältere Versionen (SSL 3.0, TLS 1.0, TLS 1.1) gelten als unsicher
  • Starke Cipher Suites mit mindestens 128-bit Verschlüsselung verwenden

Zertifikatserstellung

Bash
# Privaten Schlüssel generieren
openssl genrsa -out private.key 2048

# Certificate Signing Request (CSR) erstellen
openssl req -new -key private.key -out request.csr

# Selbstsigniertes Zertifikat erstellen
openssl x509 -req -days 365 -in request.csr -signkey private.key -out certificate.crt

Sicherheitsaspekte

  • Private Schlüssel müssen sicher verwahrt werden
  • Regelmäßige Zertifikatserneuerung
  • Verwendung starker Verschlüsselungsalgorithmen
  • Perfect Forward Secrecy (PFS) aktivieren
4. Schlüsselverwaltung

Die Schlüsselverwaltung ist ein essentieller Bestandteil der Verschlüsselung und stellt sicher, dass Schlüssel sicher erstellt, gespeichert und verwaltet werden.

Schlüsselhierarchie

Markdown
┌─────────── Schlüsselarten ─────────────┐
│ - Private Schlüssel (geheim)           │
│ - Öffentliche Schlüssel (public)       │
│ - Symmetrische Schlüssel               │
├─────────── Speicherorte ───────────────┤
│ - Schlüsselbunde (Keyrings)            │
│ - Hardware-Token                       │
│ - Smartcards                           │
└────────────────────────────────────────┘

Schlüsselverwaltungssysteme

Markdown
┌─────────── GPG/PGP ──────────────────┐
│ - E-Mail-Verschlüsselung             │
│ - Dateiverschlüsselung               │
│ - Digitale Signaturen                │
├─────────── SSH-Keys ─────────────────┤
│ - Server-Authentifizierung           │
│ - Sichere Verbindungen               │
│ - Key-Based Authentication           │
├─────────── PKI ──────────────────────┤
│ - Zertifikate                        │
│ - Certificate Authorities            │
│ - Schlüsselvalidierung               │
└──────────────────────────────────────┘

Praktische Schlüsselverwaltung

GPG-Schlüssel erstellen

Bash
# Schlüsselpaar generieren
gpg --full-generate-key

# Schlüssel auflisten
gpg --list-keys
gpg --list-secret-keys

# Schlüssel exportieren
gpg --export --armor username > public.key
gpg --export-secret-key --armor username > private.key

SSH-Schlüssel verwalten

Bash
# SSH-Schlüsselpaar erstellen
ssh-keygen -t ed25519 -C "kommentar"

# Öffentlichen Schlüssel auf Server kopieren
ssh-copy-id benutzer@server

# Schlüssel mit Passwort schützen
ssh-keygen -p -f ~/.ssh/id_ed25519

Sicherheitsrichtlinien

Markdown
┌─────────── Schlüsselsicherheit ──────┐
│ - Starke Passphrasen verwenden       │
│ - Regelmäßige Schlüsselrotation      │
│ - Sichere Backups erstellen          │
├─────────── Zugriffskontrolle ────────┤
│ - Berechtigungen richtig setzen      │
│ - Schlüssel verschlüsselt speichern  │
│ - Zugriffsprotokollierung            │
└──────────────────────────────────────┘

Schlüsselaufbewahrung

Markdown
┌─────────── Physische Sicherheit ─────┐
│ ~/.gnupg/   (GPG-Schlüssel)          │
│ ~/.ssh/     (SSH-Schlüssel)          │
│ /etc/ssl/   (SSL-Zertifikate)        │
├─────────── Berechtigungen ───────────┤
│ chmod 700 ~/.gnupg                   │
│ chmod 600 ~/.ssh/id_ed25519          │
│ chmod 644 ~/.ssh/id_ed25519.pub      │
└──────────────────────────────────────┘

Best Practices

  1. Schlüsselerstellung
  • Verwende starke Algorithmen (RSA 4096, Ed25519)
  • Setze immer eine Passphrase
  • Generiere Schlüssel auf sicheren Systemen
  1. Schlüsselspeicherung
  • Verschlüsselte Backups erstellen
  • Sichere Speichermedien verwenden
  • Zugriffsrechte korrekt setzen
  1. Schlüsselverteilung
  • Sichere Übertragungswege nutzen
  • Fingerprints verifizieren
  • Schlüsselaustausch dokumentieren
  1. Schlüsselwiderruf
  • Widerrufszertifikate erstellen
  • Sichere Aufbewahrung der Widerrufszertifikate
  • Klare Widerrufsprozesse definieren

Die Schlüsselverwaltung ist ein kritischer Bestandteil der Verschlüsselung und erfordert sorgfältige Planung und Durchführung, um die Sicherheit des Gesamtsystems zu gewährleisten.

Sicherheitsüberwachung

Die Sicherheitsüberwachung ist ein essentieller Bestandteil der Systemadministration. Sie ermöglicht dir, potenzielle Sicherheitsprobleme frühzeitig zu erkennen und darauf zu reagieren.

Überwachungsebenen

Markdown
┌─────────── Echtzeit-Monitoring ──────────┐
│ - System-Protokolle                      │
│ - Prozess-Überwachung                    │
│ - Netzwerk-Aktivitäten                   │
├─────────── Analyse-Tools ────────────────┤
│ - Log-Analysetools                       │
│ - Monitoring-Werkzeuge                   │
│ - Intrusion Detection                    │
└──────────────────────────────────────────┘
Log-Analyse

Die Log-Analyse ist dein wichtigstes Werkzeug zur Systemüberwachung. In den Log-Dateien findest du alle wichtigen Informationen über Systemereignisse, Fehler und potenzielle Sicherheitsprobleme.

Wichtige Log-Dateien

Markdown
/var/log/
├── auth.log     # Authentifizierungsversuche
├── syslog       # Systemmeldungen
├── kern.log     # Kernel-Meldungen
├── secure       # Sicherheitsereignisse
└── audit/       # Sicherheitsrelevante Events

So analysierst du die Logs effektiv:

Bash
# Echtzeit-Überwachung der Authentifizierung
tail -f /var/log/auth.log

# Nach verdächtigen Anmeldeversuchen suchen
grep "Failed password" /var/log/auth.log

# Kernel-Probleme identifizieren
grep -i error /var/log/kern.log
Monitoring-Tools

Monitoring-Tools helfen dir, den Systemzustand kontinuierlich zu überwachen. Sie zeigen dir wichtige Metriken und warnen dich bei Problemen.

Systemressourcen überwachen

Bash
# Prozesse und CPU-Auslastung
top         # Klassische Prozessübersicht
htop        # Moderne, interaktive Ansicht

# Speichernutzung analysieren
free -m     # Arbeitsspeicher in MB
vmstat 1    # Virtuelle Speicherstatistiken

# Festplattennutzung
df -h       # Dateisystembelegung
iostat      # Ein/Ausgabe-Statistiken
Intrusion Detection

Ein IDS (Intrusion Detection System) ist wie ein Wachhund für dein System. Es überwacht kontinuierlich verdächtige Aktivitäten und warnt dich bei potenziellen Einbruchsversuchen.

AIDE (Advanced Intrusion Detection Environment)

Bash
# Systemintegritätsdatenbank erstellen
aide --init

# Tägliche Überprüfung durchführen
aide --check

# Detaillierte Änderungen anzeigen
aide --update
Security Audits

Regelmäßige Sicherheitsüberprüfungen sind essentiell. Sie helfen dir, Schwachstellen zu finden, bevor Angreifer sie ausnutzen können.

Sicherheitsprüfungen durchführen

Bash
# Systemsicherheit analysieren
lynis audit system

# Nach Rootkits suchen
rkhunter --check --sk

# Offene Ports überprüfen
netstat -tulpn

Best Practices für die Überwachung

  1. Protokollierung
  • Aktiviere ausführliche Logging für sicherheitsrelevante Ereignisse
  • Richte Log-Rotation ein, um Speicherplatz zu sparen
  • Sichere wichtige Logs regelmäßig
  1. Automatisierung
  • Erstelle Skripte für regelmäßige Überprüfungen
  • Richte automatische Benachrichtigungen ein
  • Plane regelmäßige Sicherheitsaudits
  1. Dokumentation
  • Führe ein Protokoll über erkannte Probleme
  • Dokumentiere alle Sicherheitsvorfälle
  • Erstelle Berichte über Systemzustand

Die kontinuierliche Sicherheitsüberwachung ist ein wichtiger Baustein deiner Systemadministration. Nur durch regelmäßige Kontrollen kannst du die Sicherheit deines Systems gewährleisten.

Best Practices

Als Linux-Administrator musst du bestimmte Best Practices für die Sicherheit deines Systems beachten.

Sicherheits-Checklisten

Markdown
┌─────────── Tägliche Checks ─────────────┐
│ - Log-Dateien prüfen                    │
│ - Systemressourcen überwachen           │
│ - Backup-Status kontrollieren           │
├─────────── Wöchentliche Checks ─────────┤
│ - Sicherheitsupdates einspielen         │
│ - IDS-Berichte auswerten                │
│ - Benutzerkonten überprüfen             │
└─────────────────────────────────────────┘
Regelmäßige Audits

So führst du systematische Sicherheitsüberprüfungen durch:

Bash
# Systemsicherheit prüfen
lynis audit system

# Offene Ports scannen
nmap -sT -p- localhost

# Dateiberechtigungen überprüfen
find / -type f -perm -4000 -ls
Incident Response

Bei Sicherheitsvorfällen musst du schnell und systematisch handeln:

Markdown
┌─────────── Incident-Workflow ───────────┐
│ 1. Erkennung des Vorfalls               │
│ 2. Isolation des Problems               │
│ 3. Analyse der Ursache                  │
│ 4. Behebung des Problems                │
│ 5. Dokumentation                        │
└─────────────────────────────────────────┘
Dokumentation

Eine gute Dokumentation ist essentiell für die Systemsicherheit:

Markdown
# Wichtige Dokumentationsbereiche
/var/log/
├── security/       # Sicherheitsvorfälle
├── changes/        # Systemänderungen
└── incidents/      # Vorfallsberichte

Die konsequente Anwendung dieser Best Practices hilft dir, dein System sicher und stabil zu betreiben.

Übung

Sicherheitsüberwachung eines Webservers

Szenario: Du bist der neue Linux-Administrator in einem kleinen Unternehmen. Das Unternehmen betreibt einen Webserver, der in letzter Zeit verdächtige Aktivitäten aufweist. Deine Aufgabe ist es, die Sicherheit des Servers zu überprüfen und potenzielle Probleme zu identifizieren.

Aufgaben:
  1. Überprüfe die letzten 50 Einträge im Apache-Zugriffslog auf verdächtige Aktivitäten.
  2. Finde heraus, ob es in den letzten 24 Stunden fehlgeschlagene SSH-Anmeldeversuche gab.
  3. Überprüfe, ob der Webserver-Prozess (Apache) mit den korrekten Berechtigungen läuft.
  4. Führe einen grundlegenden Sicherheitsaudit des Systems durch.
  5. Erstelle ein einfaches Skript, das dich per E-Mail benachrichtigt, wenn mehr als 100 fehlgeschlagene SSH-Anmeldeversuche in einer Stunde auftreten.
Mögliche Lösung:

Apache-Zugriffslog überprüfen:

Bash
sudo tail -n 50 /var/log/apache2/access.log | grep -E "POST|PUT|DELETE|CONNECT"

Fehlgeschlagene SSH-Anmeldeversuche prüfen:

Bash
sudo grep "Failed password" /var/log/auth.log | grep "$(date -d '24 hours ago' +'%b %d')"

Apache-Prozessberechtigungen überprüfen:

Bash
ps aux | grep apache2

Grundlegenden Sicherheitsaudit durchführen:

Bash
sudo lynis audit system

Skript für SSH-Anmeldeversuch-Benachrichtigung:

ShellScript
#!/bin/bash
THRESHOLD=100
COUNT=$(grep "Failed password" /var/log/auth.log | grep "$(date +'%b %d %H')" | wc -l)
if [ $COUNT -gt $THRESHOLD ]; then
    echo "Warnung: Mehr als $THRESHOLD fehlgeschlagene SSH-Anmeldeversuche in der letzten Stunde!" | mail -s "Sicherheitswarnung" admin@example.com
fi

Speichere dieses Skript als /usr/local/bin/ssh_monitor.sh, mache es ausführbar mit chmod +x /usr/local/bin/ssh_monitor.sh und füge es zum Crontab hinzu, um es stündlich auszuführen:

TypeScript
0 * * * * /usr/local/bin/ssh_monitor.sh

Diese Übung deckt verschiedene Aspekte der Sicherheitsüberwachung ab und gibt dir praktische Erfahrung im Umgang mit Logs, Prozessen und automatisierten Überprüfungen.

Fazit:

In diesem Artikel hast du die wichtigsten Aspekte der Linux-Sicherheit kennengelernt. Von der grundlegenden Systemhärtung über die Netzwerksicherheit bis hin zur Verschlüsselung und Sicherheitsüberwachung wurden alle wesentlichen Bereiche behandelt. Du hast gelernt, wie du Benutzer und Berechtigungen verwaltest, dein System vor Angriffen schützt und die Sicherheit kontinuierlich überwachst.

Die behandelten Konzepte und Werkzeuge bilden das Fundament für eine sichere Linux-Administration. Besonders wichtig ist das Zusammenspiel der verschiedenen Sicherheitsebenen – von der Zugriffskontrolle über die Verschlüsselung bis hin zur kontinuierlichen Überwachung. Nur wenn alle diese Komponenten ineinandergreifen, kannst du ein wirklich sicheres System gewährleisten.

Im nächsten und letzten Teil unserer Serie „Linux-Administration“ werden wir uns mit „Virtualisierung und VM-Management“ beschäftigen. Dort lernst du, wie du virtuelle Maschinen erstellst, verwaltest und überwachst, sowie die verschiedenen Virtualisierungstechnologien wie KVM und den Virtual Machine Manager (VMM) effektiv einsetzt.

Bis dahin, happy administrating!

Schlagwörter

Ähnliche Beiträge