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.
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
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.
Systemsicherheits-Komponenten:
┌─────────── Systemhärtung ───────────┐
│ - Aktuelle Software │
│ - Sichere Konfiguration │
│ - Minimale Dienste │
├─────────── Zugriffskontrolle ───────┤
│ - Benutzerrechte │
│ - Firewall-Regeln │
│ - Netzwerkzugriff │
├─────────── Überwachung ─────────────┤
│ - System-Logging │
│ - Monitoring │
│ - Warnmeldungen │
└─────────────────────────────────────┘
Wichtige Aspekte der Systemsicherheit:
- Aktuelle Software
- Regelmäßige Systemupdates
- Sicherheitspatches installieren
- Veraltete Software entfernen
- Minimale Angriffsfläche
- Nur benötigte Dienste aktivieren
- Offene Ports beschränken
- Unnötige Software entfernen
- 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.
Datensicherheits-Aspekte:
┌─────────── Datenschutz ────────────┐
│ - Verschlüsselung │
│ - Zugriffskontrollen │
│ - Berechtigungen │
├─────────── Datenverfügbarkeit ─────┤
│ - Backup-Strategien │
│ - RAID-Systeme │
│ - Redundanz │
├─────────── Datenintegrität ────────┤
│ - Checksummen │
│ - Audit-Trails │
│ - Versionierung │
└────────────────────────────────────┘
Wichtige Aspekte der Datensicherheit:
- Datenschutz
- Sensible Daten identifizieren und klassifizieren
- Zugriff nur für autorisierte Benutzer
- Verschlüsselung wichtiger Daten
- Datenverfügbarkeit
- Regelmäßige Backups durchführen
- Redundante Systeme einrichten
- Disaster-Recovery-Plan erstellen
- 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.
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
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.
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.
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:
# 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)
# 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
# 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.
Passwort-Komponenten:
┌─────────── Komplexität ───────────┐
│ - Mindestlänge │
│ - Zeichenarten │
│ - Wiederholungen │
├─────────── Gültigkeit ────────────┤
│ - Maximales Alter │
│ - Änderungsintervall │
│ - Historie │
└───────────────────────────────────┘
a) Passwort-Anforderungen konfigurieren
# 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
# 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
# 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
# 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.
Dienst-Management:
┌─────────── Analyse ─────────────┐
│ - Laufende Dienste │
│ - Offene Ports │
│ - Abhängigkeiten │
├─────────── Optimierung ─────────┤
│ - Unnötige Dienste stoppen │
│ - Ports schließen │
│ - Autostart deaktivieren │
└─────────────────────────────────┘
a) Laufende Dienste identifizieren:
# Aktive Dienste anzeigen
systemctl list-units --type=service --state=running
# Offene Ports überprüfen
ss -tulpn
b) Unnötige Dienste deaktivieren:
# 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:
# 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:
# 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.
Update-Komponenten:
┌─────────── Paketquellen ──────────┐
│ - Repository-Listen │
│ - Signatur-Prüfung │
│ - Mirror-Auswahl │
├─────────── Updates ───────────────┤
│ - Sicherheitsupdates │
│ - Systemupdates │
│ - Anwendungsupdates │
└───────────────────────────────────┘
a) Update-Prozess
- Paketquellen aktualisieren
- Verfügbare Updates prüfen
- Updates installieren
- 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:
# 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
# Repository-Listen prüfen
ls -l /etc/apt/sources.list.d/
# Signaturschlüssel verwalten
apt-key list
e) Update-Logging und Monitoring:
# 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:
# 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:
- Vor großen Updates immer Backup erstellen
- Updates zuerst in Testumgebung testen
- Update-Logs regelmäßig prüfen
- 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.
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)
# 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
# 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
# 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
sudo nano /etc/ssh/sshd_config
# 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
# 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
# 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
sudo apt install fail2ban
Konfiguration anpassen:
# 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
# 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
# In /etc/ssh/sshd_config
# Verbindungszeitlimits setzen
ClientAliveInterval 300
ClientAliveCountMax 2
LoginGraceTime 30
g) X11-Forwarding und TCP-Forwarding
# 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
Port-Scanning-Komponenten:
┌─────────── Scanning-Arten ─────────┐
│ - TCP-Scans │
│ - UDP-Scans │
│ - Service-Detection │
├─────────── Monitoring ─────────────┤
│ - Echtzeit-Überwachung │
│ - Log-Analyse │
│ - Anomalie-Erkennung │
└────────────────────────────────────┘
a) Port-Scanning mit nmap
# 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
# Echtzeit-Netzwerk-Monitoring
sudo tcpdump -i eth0
# Prozess-Monitoring
htop
netstat -tulpn
# Systemüberwachung
vmstat 1
iostat -x 1
e) Traffic-Analyse
# 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.
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:
# 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:
# 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:
# 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:
# E-Mail-Benachrichtigung bei verdächtigen Aktivitäten
sudo apt install logwatch
sudo nano /etc/logwatch/conf/logwatch.conf
Regelmäßige Systemprüfungen:
# 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:
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
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.
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.
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:
# 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:
# 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
# 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.
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:
# 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:
# 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
# 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
# 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
# ACLs sichern
getfacl -R /shared/projekt/ > acl_backup.txt
# ACLs wiederherstellen
setfacl --restore=acl_backup.txt
d) ACL-Vererbung
# 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.
Sudo-Komponenten:
┌─────────── Konfiguration ─────────┐
│ - /etc/sudoers │
│ - /etc/sudoers.d/ │
│ - Benutzer-Richtlinien │
├─────────── Berechtigungen ────────┤
│ - Befehle │
│ - Hosts │
│ - Benutzer/Gruppen │
└───────────────────────────────────┘
a) Grundlegende Sudo-Konfiguration
Sudo-Konfiguration sicher bearbeiten
sudo visudo
Beispiel einer Sudo-Regel:
anna ALL=(ALL:ALL) /usr/bin/apt
│ │ │ │ └── Erlaubter Befehl
│ │ │ └──────── Erlaubte Gruppen
│ │ └──────────── Erlaubte Benutzer
│ └──────────────── Erlaubte Hosts
└───────────────────── Benutzername
b) Häufige Sudo-Konfigurationen:
# 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
# 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
# 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
# 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
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:
/var/log/auth.log
(Debian/Ubuntu) oder/var/log/secure
(RHEL/CentOS):- Authentifizierungsversuche
- Sudo-Verwendung
- SSH-Zugriffe
- Passwortänderungen
/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:
# 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:
# 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:
# 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.
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.
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:
# 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.
Verschlüsselungs-Optionen:
┌─────────── eCryptfs ────────────┐
│ - Verzeichnisverschlüsselung │
│ - Home-Verzeichnisse │
│ - Pro-Benutzer │
├─────────── EncFS ───────────────┤
│ - FUSE-basiert │
│ - Transparent │
│ - Flexibel │
└─────────────────────────────────┘
a) eCryptfs für Home-Verzeichnisse
# 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
# 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
# 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
┌─────────── Schlüsselarten ─────────────┐
│ - Private Schlüssel (geheim) │
│ - Öffentliche Schlüssel (public) │
│ - Symmetrische Schlüssel │
├─────────── Speicherorte ───────────────┤
│ - Schlüsselbunde (Keyrings) │
│ - Hardware-Token │
│ - Smartcards │
└────────────────────────────────────────┘
Schlüsselverwaltungssysteme
┌─────────── 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
# 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
# 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
┌─────────── Schlüsselsicherheit ──────┐
│ - Starke Passphrasen verwenden │
│ - Regelmäßige Schlüsselrotation │
│ - Sichere Backups erstellen │
├─────────── Zugriffskontrolle ────────┤
│ - Berechtigungen richtig setzen │
│ - Schlüssel verschlüsselt speichern │
│ - Zugriffsprotokollierung │
└──────────────────────────────────────┘
Schlüsselaufbewahrung
┌─────────── 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
- Schlüsselerstellung
- Verwende starke Algorithmen (RSA 4096, Ed25519)
- Setze immer eine Passphrase
- Generiere Schlüssel auf sicheren Systemen
- Schlüsselspeicherung
- Verschlüsselte Backups erstellen
- Sichere Speichermedien verwenden
- Zugriffsrechte korrekt setzen
- Schlüsselverteilung
- Sichere Übertragungswege nutzen
- Fingerprints verifizieren
- Schlüsselaustausch dokumentieren
- 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
┌─────────── 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
/var/log/
├── auth.log # Authentifizierungsversuche
├── syslog # Systemmeldungen
├── kern.log # Kernel-Meldungen
├── secure # Sicherheitsereignisse
└── audit/ # Sicherheitsrelevante Events
So analysierst du die Logs effektiv:
# 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
# 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)
# 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
# Systemsicherheit analysieren
lynis audit system
# Nach Rootkits suchen
rkhunter --check --sk
# Offene Ports überprüfen
netstat -tulpn
Best Practices für die Überwachung
- Protokollierung
- Aktiviere ausführliche Logging für sicherheitsrelevante Ereignisse
- Richte Log-Rotation ein, um Speicherplatz zu sparen
- Sichere wichtige Logs regelmäßig
- Automatisierung
- Erstelle Skripte für regelmäßige Überprüfungen
- Richte automatische Benachrichtigungen ein
- Plane regelmäßige Sicherheitsaudits
- 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
┌─────────── 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:
# 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:
┌─────────── 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:
# 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:
- Überprüfe die letzten 50 Einträge im Apache-Zugriffslog auf verdächtige Aktivitäten.
- Finde heraus, ob es in den letzten 24 Stunden fehlgeschlagene SSH-Anmeldeversuche gab.
- Überprüfe, ob der Webserver-Prozess (Apache) mit den korrekten Berechtigungen läuft.
- Führe einen grundlegenden Sicherheitsaudit des Systems durch.
- 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:
sudo tail -n 50 /var/log/apache2/access.log | grep -E "POST|PUT|DELETE|CONNECT"
Fehlgeschlagene SSH-Anmeldeversuche prüfen:
sudo grep "Failed password" /var/log/auth.log | grep "$(date -d '24 hours ago' +'%b %d')"
Apache-Prozessberechtigungen überprüfen:
ps aux | grep apache2
Grundlegenden Sicherheitsaudit durchführen:
sudo lynis audit system
Skript für SSH-Anmeldeversuch-Benachrichtigung:
#!/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:
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!