OWASP Top 10 Sicherheitslücken 2025
OWASP Top 10 Sicherheitslücken 2025 – Erklärt mit Beispielen
Die OWASP Top 10 ist eine regelmäßig aktualisierte Liste der 10 kritischsten Sicherheitslücken in Webanwendungen. Diese Sicherheitslücken sind nicht hypothetisch – sie werden in der Praxis regelmäßig ausgenutzt und verursachen erhebliche Schäden. Dieser Leitfaden erklärt jede Schwachstelle mit praktischen Beispielen und Schutzmaßnahmen.
A01: Broken Access Control (Defekte Zugriffskontrolle)
Beschreibung: Defekte Zugriffskontrolle bedeutet, dass Benutzer auf Ressourcen zugreifen können, auf die sie keine Berechtigung haben. Dies ist die häufigste Sicherheitslücke in modernen Webanwendungen.
Beispiel einer anfälligen Anwendung:
// Vulnerable PHP Code $_SESSION['user_id'] = 123; $requested_user_id = $_GET['user_id']; // FEHLER: Direkte Verwendung des Parameters ohne Validierung $query = "SELECT * FROM users WHERE id = " . $requested_user_id; $result = mysqli_query($conn, $query); echo json_encode($result);
Ein Angreifer könnte einfach die URL ändern von /profile.php?user_id=123 zu /profile.php?user_id=456 und das Profil eines anderen Benutzers sehen.
Schutzmechanismen:
- Immer die Berechtigung des aktuellen Benutzers überprüfen
- White-List-Ansatz verwenden (nur explizit erlaubte Aktionen)
- Role-Based Access Control (RBAC) implementieren
- Sensitive URLs und Parameter nicht in der Benutzeroberfläche exponieren
Sichere Implementierung:
// Secure PHP Code
function getUserProfile($requested_user_id) {
$current_user_id = $_SESSION['user_id'];
// Schritt 1: Verify the requested user matches the logged-in user
if ($requested_user_id != $current_user_id) {
http_response_code(403);
die('Zugriff verweigert');
}
// Schritt 2: Use prepared statement
$query = "SELECT id, name, email FROM users WHERE id = ?";
$stmt = $conn->prepare($query);
$stmt->bind_param("i", $requested_user_id);
$stmt->execute();
return $stmt->get_result()->fetch_assoc();
}
A02: Cryptographic Failures (Kryptographische Fehler)
Beschreibung: Sensible Daten sind nicht ausreichend geschützt. Dies umfasst fehlende oder schwache Verschlüsselung, schwache Hashing-Algorithmen und unsichere Datenübertragung.
Häufige Fehler:
- Passwörter im Klartext speichern oder mit schwachen Hashes wie MD5/SHA1
- HTTP statt HTTPS verwenden für sensible Daten
- Hard-codierte Verschlüsselungsschlüssel im Quellcode
- Alte Verschlüsselungsalgorithmen wie DES oder RC4
Unsicheres Passwort-Hashing:
// FEHLER: Nie verwenden! $password_hash = md5($password); $password_hash = sha1($password);
Sichere Passwort-Speicherung:
// Richtig: bcrypt mit PHP
$hashed_password = password_hash($password, PASSWORD_BCRYPT);
// Verifizierung:
if (password_verify($password, $hashed_password)) {
echo "Passwort korrekt";
} else {
echo "Passwort falsch";
}
Sichere Kommunikation:
- Immer HTTPS/TLS verwenden (mindestens TLS 1.2, besser 1.3)
- Strong cipher suites konfigurieren
- HSTS (HTTP Strict Transport Security) aktivieren
- Sensitive Daten nicht in URLs speichern
A03: Injection (Injection-Angriffe)
Beschreibung: Der Angreifer injiziert bösartigen Code in eine Anwendung durch Eingabefelder. Dies umfasst SQL Injection, OS Command Injection, XSS und weitere Varianten.
SQL Injection Beispiel:
// FEHLER: Anfällig für SQL Injection $username = $_POST['username']; $query = "SELECT * FROM users WHERE username = '" . $username . "'"; $result = mysqli_query($conn, $query); // Angreifer gibt ein: ' OR '1'='1 // Resultierende Query: SELECT * FROM users WHERE username = '' OR '1'='1' // Dies gibt ALLE Benutzer zurück!
Sichere SQL mit Prepared Statements:
// Sichere Implementierung mit Prepared Statements
$username = $_POST['username'];
$password = $_POST['password'];
$query = "SELECT * FROM users WHERE username = ? AND password = ?";
$stmt = $conn->prepare($query);
$stmt->bind_param("ss", $username, $password);
$stmt->execute();
$result = $stmt->get_result();
Command Injection verhindern:
// FEHLER
$filename = $_GET['file'];
system("cat " . $filename); // Angreifer: file.txt; rm -rf /
// RICHTIG
$filename = escapeshellarg($_GET['file']);
system("cat " . $filename);
// BESSER: Nicht system() verwenden, sondern PHP-Funktionen
$content = file_get_contents($_GET['file']);
A04: Insecure Design (Unsicheres Design)
Beschreibung: Die Anwendung wurde von Anfang an ohne Sicherheit im Blick designt. Dies ist eher eine Kategorie als eine spezifische technische Lücke.
Beispiele unsicheren Designs:
- Keine Authentifizierung oder nur schwache Authentifizierung
- Keine Ratengrenzung bei Anmeldeversuchen
- Fehlende Validierung auf Seite des Servers
- Keine Datenschutz by Design Prinzipien
Sicheres Design-Prinzipien:
- Security von Anfang an einplanen (Security by Design)
- Threat Modeling durchführen
- Sicherheitsanforderungen dokumentieren
- Regelmäßige Sicherheitsbewertungen durchführen
- Principle of Least Privilege anwenden
A05: Security Misconfiguration (Sicherheitsmisconfiguration)
Beschreibung: Sicherheitsrelevante Einstellungen sind falsch konfiguriert oder nicht auf Standardwerte überprüft.
Häufige Fehler:
- Default-Passwörter nicht geändert (z.B. admin/admin)
- Debug-Modus in Produktion aktiviert
- Fehlende oder unsichere Sicherheits-Header
- Sensitive Dateien exponieren (z.B. .git, .env, web.config)
- Ungepatchte Komponenten oder Frameworks
Sicherheits-Header konfigurieren (Apache):
# /etc/apache2/mods-enabled/headers.conf Header set X-Content-Type-Options "nosniff" Header set X-Frame-Options "SAMEORIGIN" Header set X-XSS-Protection "1; mode=block" Header set Strict-Transport-Security "max-age=31536000; includeSubDomains" Header set Content-Security-Policy "default-src 'self'"
Nginx konfigurieren:
# /etc/nginx/nginx.conf add_header X-Content-Type-Options "nosniff" always; add_header X-Frame-Options "SAMEORIGIN" always; add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always; add_header Content-Security-Policy "default-src 'self'" always;
A06: Vulnerable and Outdated Components (Anfällige und veraltete Komponenten)
Beschreibung: Die Anwendung verwendet Libraries und Frameworks mit bekannten Sicherheitslücken.
Verwaltung von Abhängigkeiten:
# Node.js: package.json überprüfen npm audit npm audit fix # Python: requirements.txt überprüfen pip check safety check # Composer (PHP) composer outdated --direct composer update
Sicherheits-Updates automatisieren:
- Regelmäßige automatische Patches einrichten
- Dependency scanning in CI/CD Pipeline integrieren
- Software Bill of Materials (SBOM) führen
- Nur notwendige Abhängigkeiten verwenden
A07: Identification and Authentication Failures (Authentifizierungs- und Identifikationsfehler)
Beschreibung: Schwache oder fehlerhaft implementierte Authentifizierungsmechanismen.
Häufige Fehler:
- Keine Schutzmaßnahmen gegen Brute-Force-Angriffe
- Standardmäßige, schwache oder fehlende Passwortrichtlinien
- Session-Management ist nicht sicher (keine HttpOnly Flags, kurze Timeouts)
- Ungeschützte Passwort-Recovery-Funktionen
Sichere Session-Verwaltung mit PHP:
// Session konfigurieren
ini_set('session.cookie_httponly', 1); // Nicht für JavaScript zugänglich
ini_set('session.cookie_secure', 1); // Nur über HTTPS
ini_set('session.cookie_samesite', 'Strict');
ini_set('session.cookie_lifetime', 1800); // 30 Minuten
session_start();
// Session regenerieren nach Login
session_regenerate_id(true);
Multi-Factor Authentication (MFA) implementieren:
- TOTP (Time-based One-Time Password) wie Google Authenticator
- SMS/Email Codes (weniger sicher als TOTP)
- Hardware Keys (FIDO2/U2F)
- Biometrische Authentifizierung
A08: Software and Data Integrity Failures (Fehler bei Software- und Datenintegrität)
Beschreibung: Die Anwendung vertraut auf Plugins, Libraries oder Updates von möglicherweise unsicheren Quellen.
Schutzmaßnahmen:
- Code-Signierung verwenden
- Cryptographic signatures überprüfen vor Installation
- Plugins nur von vertrauenswürdigen Quellen
- CI/CD Pipeline absichern gegen unerwünschte Änderungen
- Secure Supply Chain Management etablieren
Integrität überprüfen mit SHA256:
# Datei-Hash berechnen sha256sum software.tar.gz # Verifizierung gegen Referenz-Hash sha256sum -c checksums.txt # GPG-Signatur verifizieren gpg --verify software.tar.gz.sig software.tar.gz
A09: Security Logging and Monitoring Failures (Fehler beim Logging und Monitoring)
Beschreibung: Sicherheitsrelevante Ereignisse werden nicht protokolliert oder Logs werden nicht überwacht.
Was sollte geloggt werden:
- Alle Anmeldeversuche (erfolgreich und fehlgeschlagen)
- Zugriff auf sensitive Daten
- Datenbankfehler und Zugriffsfehler
- Administrative Aktionen
- Verdächtige Aktivitäten (viele fehlgeschlagene Anmeldungen, SQL-Fehler)
Sichere Logging-Implementierung:
// PHP: Sicheres Logging
function logSecurityEvent($event_type, $user_id, $details, $severity = 'INFO') {
$timestamp = date('Y-m-d H:i:s');
$ip_address = $_SERVER['REMOTE_ADDR'];
$log_entry = "$timestamp | $severity | User: $user_id | IP: $ip_address | Event: $event_type | Details: $details\n";
// Loggen in separate Datei mit restriktiven Rechten
error_log($log_entry, 3, '/var/log/app/security.log');
}
// Verwendung:
logSecurityEvent('LOGIN_ATTEMPT', $user_id, 'Successful login', 'INFO');
logSecurityEvent('BRUTE_FORCE', 'unknown', 'Too many failed attempts from ' . $_SERVER['REMOTE_ADDR'], 'WARNING');
Monitoring und Alerting:
- Logs zentral sammeln (ELK Stack, Splunk, Datadog)
- Anomalien automatisch erkennen
- Alerts bei verdächtigen Aktivitäten konfigurieren
- Logs für längere Zeit speichern (mindestens 1 Jahr)
- Regelmäßig Log-Reports prüfen
A10: Server-Side Request Forgery (SSRF)
Beschreibung: Ein Angreifer veranlasst den Server, unerwünschte Anfragen zu stellen, meist zu internen Ressourcen.
SSRF Beispiel:
// FEHLER: Anfällig für SSRF $url = $_GET['url']; $content = file_get_contents($url); // Angreifer nutzt: http://localhost:8080/admin // oder: http://169.254.169.254/latest/meta-data/ (AWS metadata service)
SSRF-Schutz:
function isSafeUrl($url) {
// Parse URL
$parsed = parse_url($url);
// Nur HTTP(S) erlauben
if (!in_array($parsed['scheme'], ['http', 'https'])) {
return false;
}
// Localhost/Private IPs blockieren
$host = gethostbyname($parsed['host']);
$reserved_ips = [
'127.0.0.1',
'::1',
'0.0.0.0',
'169.254.169.254', // AWS metadata
];
if (in_array($host, $reserved_ips) || strpos($host, '192.168.') === 0) {
return false;
}
return true;
}
// Verwendung
$url = $_GET['url'];
if (isSafeUrl($url)) {
$content = file_get_contents($url);
} else {
die('Ungültige URL');
}
Prioritäts- und Risiko-Übersicht
| Rang | Lücke | Kritikalität | Häufigkeit | Detektierbarkeit |
|---|---|---|---|---|
| A01 | Broken Access Control | Kritisch | Sehr häufig | Mittel |
| A02 | Cryptographic Failures | Kritisch | Häufig | Schwierig |
| A03 | Injection | Kritisch | Sehr häufig | Einfach |
| A04 | Insecure Design | Kritisch | Häufig | Mittel |
| A05 | Security Misconfiguration | Hoch | Sehr häufig | Einfach |
| A06 | Vulnerable Components | Hoch | Häufig | Mittel |
| A07 | Auth Failures | Kritisch | Häufig | Mittel |
| A08 | Integrity Failures | Hoch | Selten | Schwierig |
| A09 | Logging Failures | Mittel | Häufig | Einfach |
| A10 | SSRF | Hoch | Mittel | Mittel |