Authentifizierungsumgehung durch alternativen Namen

Beschreibung

Authentifizierungsumgehung durch alternativen Namen ist eine Schwachstelle, die auftritt, wenn ein Produkt Authentifizierung basierend auf dem Namen einer zugegriffenen Ressource oder dem Namen des zugreifenden Akteurs durchführt, aber nicht alle möglichen Namen für diese Ressource oder diesen Akteur ordnungsgemäß prüft. Viele Systeme ermöglichen es, Ressourcen über mehrere Namen zu referenzieren - durch URL-Kodierung, Groß-/Kleinschreibungsvariationen, Unicode-Repräsentationen, Path-Traversal-Sequenzen oder Dateierweiterungs-Aliase. Wenn Authentifizierungsprüfungen nur eine Namensrepräsentation validieren, aber Zugang über eine alternative Repräsentation derselben Ressource gewährt wird, können Angreifer Sicherheitskontrollen umgehen.

Risiko

Authentifizierungsumgehung durch alternative Namen erzeugt erhebliche Sicherheitsrisiken, da Angreifer auf geschützte Ressourcen zugreifen können, indem sie einfach Ressourcenbezeichner kodieren oder umformulieren. URL-Kodierung ermöglicht es, Zeichen auf mehrere Arten darzustellen (%2F für /, %2e für .), was die Umgehung pfadbasierter Zugriffskontrollen ermöglicht. Dateisysteme ohne Groß-/Kleinschreibungsunterscheidung können Zugang zu ADMIN.PHP ermöglichen, wenn admin.php blockiert ist. Unicode-Normalisierungsprobleme können verschiedene Zeichensequenzen auf dieselbe Ressource verweisen lassen. Backslash-Kodierung in Webservern kann .aspx-Dateibeschränkungen umgehen. Das Risiko wird verstärkt, da diese Umgehungen oft die Sicherheitsüberwachung umgehen, weil die alternativen Namen möglicherweise nicht mit Logging-Mustern oder Intrusion-Detection-Signaturen übereinstimmen.

Lösung

Vermeiden Sie Sicherheitsentscheidungen, die ausschließlich auf Ressourcennamen basieren, wenn alternative Namen möglich sind. Implementieren Sie Kanonisierung - dekodieren und normalisieren Sie alle Eingaben in ihre kanonische Form vor der Validierung, um Double-Decoding- und Kodierungsangriffe zu verhindern. Wenden Sie strikte Eingabevalidierung mit einem "akzeptiere bekannt Gutes"-Ansatz mit vordefinierten akzeptablen Eingaben an, die den Spezifikationen entsprechen. Lösen Sie Ressourcenpfade in absolute kanonische Formen auf, bevor Sie Zugriffskontrollentscheidungen treffen. Verwenden Sie vom Framework bereitgestellte Sicherheitsmechanismen, die Kanonisierung korrekt handhaben. Implementieren Sie Allowlist-Validierung anstelle von Blocklist-Filterung von Ressourcennamen. Testen Sie Authentifizierung mit verschiedenen Kodierungsschemata einschließlich URL-Kodierung, Unicode, Double-Encoding und Groß-/Kleinschreibungsvariationen.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Zugriffskontrolle Angreifer können beabsichtigte Sicherheitsbeschränkungen umgehen, indem sie alternative Namenskonventionen verwenden, um auf geschützte Ressourcen zu verweisen. Dies umgeht Authentifizierungsanforderungen und ermöglicht unbefugten Zugriff auf eingeschränkte Funktionalität und sensible Daten.

Beispielcode

Anfälliger Code (Python/Web)

Die folgenden Beispiele demonstrieren Authentifizierungsumgehung durch alternativen Namen:

# Anfällig: Pfadbasierte Zugriffskontrolle ohne Kanonisierung
from flask import Flask, request, abort

app = Flask(__name__)

# Liste geschützter Pfade
PROTECTED_PATHS = ['/admin', '/admin/', '/api/admin']

@app.before_request
def check_protected_paths():
    path = request.path

    # Anfällig: Prüft nur exakte Pfadübereinstimmungen
    if path in PROTECTED_PATHS:
        if not is_authenticated():
            abort(401)

    # Umgehung: /admin -> erlaubt (exakte Übereinstimmungsprüfung)
    # Umgehung: /Admin -> umgeht Prüfung (Groß-/Kleinschreibung)
    # Umgehung: /admin%2f -> umgeht Prüfung (kodierter /)
    # Umgehung: /./admin -> umgeht Prüfung (Path Traversal)
    # Umgehung: //admin -> umgeht Prüfung (Doppelschrägstrich)

@app.route('/admin')
def admin_panel():
    return render_template('admin.html')

// Anfällig: Dateizugriffskontrolle nach Erweiterung
public class VulnerableFileAccess {

    private static final List<String> RESTRICTED_EXTENSIONS =
        Arrays.asList(".aspx", ".config", ".cs");

    public boolean isAccessAllowed(String filename) {
        // Anfällig: Prüft nur Kleinbuchstaben-Erweiterungen
        for (String ext : RESTRICTED_EXTENSIONS) {
            if (filename.endsWith(ext)) {
                return false;
            }
        }
        return true;

        // Umgehung: file.ASPX -> umgeht Prüfung (Groß-/Kleinschreibung)
        // Umgehung: file.aspx%00.txt -> umgeht Prüfung (Null-Byte)
        // Umgehung: file.as%70x -> umgeht Prüfung (kodiertes 'p')
    }
}

<?php
// Anfällig: Benutzernamenvalidierung durch alternative Repräsentation
function authenticate($username, $password) {
    // Admin-Login vom Web blockieren
    if ($username === "admin") {
        return false;  // Admin blockiert
    }

    // Anfällig: Normalisiert Benutzernamen nicht
    return check_credentials($username, $password);

    // Umgehung: "Admin" -> umgeht Prüfung (Groß-/Kleinschreibung)
    // Umgehung: "admin " -> umgeht Prüfung (nachfolgendes Leerzeichen)
    // Umgehung: "аdmin" -> umgeht Prüfung (kyrillisches 'а')
}

// Anfällig: Pfadzugriffskontrolle
function is_restricted_path($path) {
    $restricted = array('/etc/passwd', '/etc/shadow');

    // Anfällig: Keine Kanonisierung
    return in_array($path, $restricted);

    // Umgehung: /etc/passwd -> blockiert
    // Umgehung: /etc//passwd -> umgeht Prüfung
    // Umgehung: /etc/./passwd -> umgeht Prüfung
    // Umgehung: /etc/dummy/../passwd -> umgeht Prüfung
}
?>

Korrigierter Code (Python/Web)

# Korrigiert: Pfadbasierte Zugriffskontrolle mit Kanonisierung
from flask import Flask, request, abort
import os
from urllib.parse import unquote

app = Flask(__name__)

PROTECTED_PATH_PREFIXES = ['/admin', '/api/admin']

def canonicalize_path(path):
    """Normalisiert Pfad in kanonische Form"""
    # URL dekodieren
    decoded = unquote(path)

    # Double-Encoding behandeln
    while decoded != unquote(decoded):
        decoded = unquote(decoded)

    # Pfadtrenner normalisieren und Traversal entfernen
    normalized = os.path.normpath(decoded)

    # In Kleinbuchstaben für Vergleich ohne Groß-/Kleinschreibung
    normalized = normalized.lower()

    # Mehrfache Schrägstriche entfernen
    while '//' in normalized:
        normalized = normalized.replace('//', '/')

    return normalized

@app.before_request
def check_protected_paths():
    # Korrigiert: Kanonisieren vor der Prüfung
    canonical_path = canonicalize_path(request.path)

    for protected in PROTECTED_PATH_PREFIXES:
        if canonical_path.startswith(protected):
            if not is_authenticated():
                abort(401)
            break

@app.route('/admin')
def admin_panel():
    return render_template('admin.html')

// Korrigiert: Dateizugriffskontrolle mit ordnungsgemäßer Normalisierung
import java.io.File;
import java.io.IOException;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;

public class SecureFileAccess {

    private static final Set<String> RESTRICTED_EXTENSIONS =
        Set.of(".aspx", ".config", ".cs", ".dll");

    public boolean isAccessAllowed(String filename) throws IOException {
        // Korrigiert: URL-Kodierung dekodieren
        String decoded = URLDecoder.decode(filename, StandardCharsets.UTF_8);

        // Korrigiert: Double-Encoding behandeln
        String prev;
        do {
            prev = decoded;
            decoded = URLDecoder.decode(decoded, StandardCharsets.UTF_8);
        } while (!decoded.equals(prev));

        // Korrigiert: Null-Bytes entfernen
        decoded = decoded.replace("\0", "");

        // Korrigiert: In Kleinbuchstaben für Prüfung ohne Groß-/Kleinschreibung
        String lower = decoded.toLowerCase();

        // Korrigiert: Alle Erweiterungsvariationen prüfen
        for (String ext : RESTRICTED_EXTENSIONS) {
            if (lower.endsWith(ext)) {
                return false;
            }
        }

        // Korrigiert: Verifizieren, dass kanonischer Pfad erlaubtes Verzeichnis nicht verlässt
        File file = new File(decoded);
        String canonical = file.getCanonicalPath();
        String allowedBase = new File("/var/www/public").getCanonicalPath();

        if (!canonical.startsWith(allowedBase)) {
            return false;  // Path-Traversal-Versuch
        }

        return true;
    }
}

<?php
// Korrigiert: Benutzernamenvalidierung mit Normalisierung
function authenticate($username, $password) {
    // Korrigiert: Benutzernamen normalisieren
    $normalized = normalize_username($username);

    // Admin-Login vom Web blockieren
    if ($normalized === "admin") {
        return false;
    }

    return check_credentials($normalized, $password);
}

function normalize_username($username) {
    // Leerzeichen entfernen
    $username = trim($username);

    // In Kleinbuchstaben konvertieren
    $username = strtolower($username);

    // Homoglyphen ersetzen (kyrillische, griechische Buchstaben, die wie lateinische aussehen)
    $homoglyphs = array(
        'а' => 'a',  // Kyrillisches а
        'е' => 'e',  // Kyrillisches е
        'о' => 'o',  // Kyrillisches о
        // Bei Bedarf weitere hinzufügen
    );
    $username = strtr($username, $homoglyphs);

    return $username;
}

// Korrigiert: Pfadzugriffskontrolle mit Kanonisierung
function is_restricted_path($path) {
    $restricted = array('/etc/passwd', '/etc/shadow');

    // Korrigiert: Pfad kanonisieren
    $canonical = realpath($path);

    if ($canonical === false) {
        // Pfad existiert nicht oder ist ungültig
        return true;  // Fail Closed
    }

    return in_array($canonical, $restricted);
}
?>

Die Korrektur implementiert ordnungsgemäße Kanonisierung einschließlich URL-Dekodierung, Groß-/Kleinschreibungsnormalisierung, Pfadnormalisierung und Homoglyph-Erkennung vor Authentifizierungsentscheidungen.

---

Ausgenutzt in der Praxis

ASP.NET-Authentifizierungsumgehung (Microsoft, 2004)

CVE-2004-0847 dokumentierte eine .NET-Framework-Schwachstelle, die Authentifizierungsumgehung für eingeschränkte .aspx-Dateien via Backslash-Kodierung ermöglichte. Angreifer verwendeten URL-kodierte Backslashes, um pfadbasierte Zugriffskontrollen zu umgehen.

• https://www.cvedetails.com/

URL-Kodierungsumgehung (Webanwendungen, Historisch)

CVE-2003-0317 dokumentierte URL-Zugriffsbeschränkungen, die mit URL-Kodierung umgangen wurden. Angreifer kodierten Pfadzeichen, um Authentifizierungsprüfungen zu umgehen, die nur nach unkodierten Pfaden suchten.

• https://nvd.nist.gov/

Unicode-Normalisierungsangriffe (Verschiedene Systeme, Fortlaufend)

Systeme, die Unicode-Normalisierung nicht ordnungsgemäß handhaben, wurden mit Homoglyph-Angriffen ausgenutzt, bei denen visuell ähnliche Unicode-Zeichen textbasierte Authentifizierungsprüfungen umgehen.

• https://owasp.org/

---

Tools zum Testen/Ausnutzen

• Burp Suite — Web-Sicherheitstool mit Kodierungs-/Dekodierungsfähigkeiten zum Testen von Umgehungen durch alternative Namen.

• OWASP ZAP — Sicherheitsscanner mit Fuzzing-Fähigkeiten zum Testen von Pfadvariationen.

• Confusables — Unicode-Confusables-Tool zur Identifikation von Homoglyphen.

---

CVE-Beispiele

• CVE-2003-0317 — URL-Zugriffsbeschränkungen wurden mit URL-Kodierung umgangen.

• CVE-2004-0847 — .NET-Framework-Schwachstelle ermöglichte Authentifizierungsumgehung für eingeschränkte .aspx-Dateien via Backslash-Kodierung.

---

Referenzen

1. MITRE Corporation. "CWE-289: Authentication Bypass by Alternate Name." Common Weakness Enumeration. https://cwe.mitre.org/data/definitions/289.html

2. OWASP Foundation. "Path Traversal." https://owasp.org/www-community/attacks/Path_Traversal

3. OWASP Foundation. "Input Validation Cheat Sheet." https://cheatsheetseries.owasp.org/cheatsheets/Input_Validation_Cheat_Sheet.html