Zurück zur Schwachstellen-Datenbank

Unsachgemäße Authentifizierung

Beschreibung

Unsachgemäße Authentifizierung tritt auf, wenn ein Akteur behauptet, eine bestimmte Identität zu haben, aber die Software nicht oder unzureichend beweist, dass die Behauptung korrekt ist. Dies umfasst eine breite Palette von Authentifizierungsfehlern einschließlich schwacher Passwortmechanismen, fehlender Multi-Faktor-Authentifizierung, vorhersagbarer Token, umgehbarer Authentifizierungslogik und fehlerhafter Sitzungsverwaltung. Wenn Authentifizierung umgangen oder umschifft werden kann, erlangen Angreifer unbefugten Zugriff auf geschützte Ressourcen, Benutzerkonten oder administrative Funktionen.

Risiko

Unsachgemäße Authentifizierung wird konsistent zu den kritischsten Sicherheitsschwächen gezählt. Erfolgreiche Ausnutzung ermöglicht Angreifern den Zugriff auf Benutzerkonten, Administrationspanels und eingeschränkte Funktionalität. Die Auswirkungen reichen von unbefugtem Datenzugriff bis zur vollständigen Systemkompromittierung. Angriffsvektoren umfassen Brute-Force-Angriffe, Credential Stuffing, Session Hijacking, Man-in-the-Middle-Angriffe und Authentifizierungsumgehung. Der Equifax-Breach von 2017 und zahllose andere große Vorfälle entstanden durch Authentifizierungsschwächen. Schwache OTP-Mechanismen ohne Rate-Limiting, wie bei jüngsten WordPress-Plugin-Schwachstellen gesehen, ermöglichen Brute-Force-Angriffe, die die Authentifizierung vollständig umgehen.

Lösung

Implementieren Sie starke Authentifizierungsmechanismen unter Verwendung etablierter Frameworks und Bibliotheken. Verwenden Sie Multi-Faktor-Authentifizierung (MFA) für sensible Operationen. Implementieren Sie Kontosperrung und Rate-Limiting, um Brute-Force-Angriffe zu verhindern. Verwenden Sie sichere Sitzungsverwaltung mit kryptografisch zufälligen Token. Wenden Sie ordnungsgemäßes Passwort-Hashing an (bcrypt, Argon2). Implementieren Sie sichere Passwortrichtlinien. Verwenden Sie HTTPS für allen Authentifizierungsverkehr. Validieren Sie die Authentifizierung bei jeder Anfrage für geschützte Ressourcen. Erwägen Sie passwortlose Authentifizierungsmethoden. Führen Sie regelmäßige Sicherheitsbewertungen mit Fokus auf Authentifizierungsumgehung durch.

Häufige Auswirkungen

AuswirkungDetails
ZugriffskontrolleBereich: Authentifizierungsumgehung

Angreifer erlangen unbefugten Zugriff auf Benutzerkonten, administrative Funktionen und geschützte Ressourcen.
VertraulichkeitBereich: Datenleck

Umgangene Authentifizierung legt alle Daten offen, auf die der kompromittierte Benutzer/die Rolle zugreifen kann.
IntegritätBereich: Systemkompromittierung

Administrativer Zugriff durch Authentifizierungsumgehung ermöglicht vollständige Systemkontrolle.

Beispielcode + Korrigierter Code

Anfälliger Code

# ANFÄLLIG: Kein Rate-Limiting für OTP
@app.route('/verify-otp', methods=['POST'])
def verify_otp():
    user_otp = request.form['otp']
    stored_otp = session.get('otp')

    # 6-stelliges OTP gültig für 10 Minuten
    # Kein Rate-Limiting = per Brute-Force knackbar (maximal 1 Million Versuche)
    if user_otp == stored_otp:
        session['authenticated'] = True
        return redirect('/dashboard')
    return 'Ungültiges OTP', 401

# ANFÄLLIG: Schwache Authentifizierungslogik
@app.route('/admin')
def admin_panel():
    # Prüft nur ob Benutzername existiert, nicht Passwort
    if 'username' in session:
        return render_template('admin.html')
    return redirect('/login')

# ANFÄLLIG: Vorhersagbare Sitzungstoken
def create_session(user_id):
    # Vorhersagbares Token - leicht erratbar
    token = f"session_{user_id}_{int(time.time())}"
    return token

// ANFÄLLIG: SQL-Injection in Authentifizierung
function authenticate($username, $password) {
    $query = "SELECT * FROM users WHERE username='$username' AND password='$password'";
    // ' OR '1'='1' -- umgeht Authentifizierung
    $result = mysqli_query($conn, $query);
    return mysqli_num_rows($result) > 0;
}

// ANFÄLLIG: Nur clientseitige Authentifizierungsprüfung
function checkAuth() {
    // JavaScript-Prüfung leicht umgehbar
    $isAdmin = isset($_COOKIE['isAdmin']) && $_COOKIE['isAdmin'] === 'true';
    return $isAdmin;
}

Korrigierter Code

import secrets
from datetime import datetime, timedelta
from functools import wraps

# SICHER: Rate-limitiertes OTP mit Sperrung
class OTPManager:
    def __init__(self):
        self.attempts = {}  # user_id: (attempts, lockout_until)
        self.MAX_ATTEMPTS = 5
        self.LOCKOUT_DURATION = timedelta(minutes=15)

    def verify_otp(self, user_id, submitted_otp, stored_otp):
        # Sperrung prüfen
        if user_id in self.attempts:
            attempts, lockout_until = self.attempts[user_id]
            if lockout_until and datetime.now() < lockout_until:
                raise AuthError("Konto gesperrt. Versuchen Sie es später erneut.")

        # Konstanter Zeitvergleich um Timing-Angriffe zu verhindern
        if secrets.compare_digest(submitted_otp, stored_otp):
            self.attempts.pop(user_id, None)
            return True

        # Fehlgeschlagene Versuche verfolgen
        attempts = self.attempts.get(user_id, (0, None))[0] + 1
        lockout_until = None
        if attempts >= self.MAX_ATTEMPTS:
            lockout_until = datetime.now() + self.LOCKOUT_DURATION
            attempts = 0

        self.attempts[user_id] = (attempts, lockout_until)
        return False

# SICHER: Ordnungsgemäßer Authentifizierungs-Decorator
def require_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        # Serverseitige Sitzungsvalidierung
        session_token = request.cookies.get('session_token')
        if not session_token:
            return redirect('/login')

        # Validieren, dass Token existiert und nicht abgelaufen ist
        user = validate_session_token(session_token)
        if not user:
            return redirect('/login')

        g.current_user = user
        return f(*args, **kwargs)
    return decorated

# SICHER: Kryptografisch sichere Token
def create_session_safe(user_id):
    token = secrets.token_urlsafe(32)  # 256 Bit Entropie
    store_session(token, user_id, expires_in=3600)
    return token

// SICHER: Parametrisierte Authentifizierung
function authenticate_safe($username, $password) {
    $stmt = $conn->prepare("SELECT id, password_hash FROM users WHERE username = ?");
    $stmt->bind_param("s", $username);
    $stmt->execute();
    $result = $stmt->get_result();

    if ($row = $result->fetch_assoc()) {
        // Gegen gehashtes Passwort verifizieren
        if (password_verify($password, $row['password_hash'])) {
            // Sichere Sitzung erstellen
            session_regenerate_id(true);
            $_SESSION['user_id'] = $row['id'];
            $_SESSION['authenticated'] = true;
            return true;
        }
    }
    return false;
}

// SICHER: Serverseitige Authentifizierungsverifikation
function require_admin() {
    session_start();
    if (!isset($_SESSION['authenticated']) || !$_SESSION['authenticated']) {
        header('Location: /login');
        exit;
    }
    // Rolle aus Datenbank verifizieren, nicht aus Cookie
    $user = get_user($_SESSION['user_id']);
    if ($user['role'] !== 'admin') {
        http_response_code(403);
        exit('Verboten');
    }
}

Ausgenutzt in der Praxis

WordPress WPCOM Member OTP-Umgehung (WordPress, 2025)

CVE-2025-14002 im WordPress WPCOM Member Plugin ermöglicht Brute-Force-Angriffe gegen 6-stellige OTP-Codes aufgrund fehlenden Rate-Limitings. 10 Minuten gültig ohne Versuchslimitierung ist das OTP leicht per Brute-Force knackbar.

Schneider Electric EPAS-UI (Industrie, 2025)

CVE-2025-0813 ermöglicht Authentifizierungsumgehung, wenn unbefugte Benutzer mit physischem Zugang den normalen Bootvorgang auf EPAS-UI-Workstations unterbrechen können.

Equifax-Datenleck (Equifax, 2017)

Das massive Equifax-Breach, das 147 Millionen Datensätze offenlegte, wurde durch eine Kombination von Authentifizierungs- und Autorisierungsschwächen in ihrem Webanwendungs-Framework ermöglicht.

Tools zum Testen/Ausnutzen

  • Burp Suite — Abfangen und Manipulieren von Authentifizierungsabläufen.

  • Hydra — Brute-Force-Authentifizierungstests.

  • OWASP ZAP — Automatisierte Authentifizierungstests.

CVE-Beispiele

Referenzen

  1. MITRE. "CWE-287: Improper Authentication." https://cwe.mitre.org/data/definitions/287.html

  2. OWASP. "Authentication Cheat Sheet." https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html