Zurück zur Schwachstellen-Datenbank

Path Traversal: '../filedir'

Beschreibung

Path Traversal: '../filedir' ist eine spezifische Variante der Path-Traversal-Schwachstelle, bei der Software Eingaben akzeptiert, die "../"-Sequenzen enthalten, die nicht ordnungsgemäß neutralisiert werden, wodurch Angreifer außerhalb eines beabsichtigten Verzeichnisses traversieren können, indem sie einen relativen Pfad zu einem übergeordneten Verzeichnis gefolgt von einem Zieldatei- oder -verzeichnisnamen angeben. Diese Schwachstelle adressiert speziell das häufige Angriffsmuster, bei dem die "../"-Sequenz als Präfix verwendet wird, um auf Dateien in übergeordneten Verzeichnissen zuzugreifen. Der Angriff nutzt die Standard-Unix/Linux-Konvention aus, bei der ".." auf das übergeordnete Verzeichnis verweist, wodurch Angreifer vom Arbeitsverzeichnis der Anwendung aus den Verzeichnisbaum hochklettern können, um auf sensible Systemdateien, Konfigurationsdaten oder andere geschützte Ressourcen zuzugreifen.

Risiko

Diese Schwachstelle ermöglicht es Angreifern, die beabsichtigte Verzeichnisbeschränkung zu umgehen, indem sie die übergeordnete Verzeichnisreferenz "../" gefolgt von einem Pfad zu sensiblen Dateien verwenden. Anwendungen, die Dateipfade aus Benutzereingaben konstruieren, ohne diese Traversal-Sequenzen zu bereinigen, legen ihr gesamtes lesbares Dateisystem potenziellen Angreifern offen. Kritische Dateien wie /etc/passwd, Anwendungskonfigurationsdateien mit Datenbankanmeldedaten, private Schlüssel und Quellcode werden zugänglich. Die Einfachheit und Effektivität dieses Angriffsmusters macht es zu einer der am häufigsten ausgenutzten Dateisystem-Schwachstellen. In Kombination mit Schreibfähigkeiten können Angreifer potenziell Systemkonfigurationen modifizieren oder bösartige Dateien platzieren.

Lösung

Implementieren Sie eine strikte Eingabevalidierung, die jede Eingabe erkennt und ablehnt, die "../"-Sequenzen oder deren codierte Varianten enthält, einschließlich URL-Codierung (%2e%2e%2f), doppelter URL-Codierung und Unicode-Darstellungen. Verwenden Sie kanonische Pfadauflösungsfunktionen, um alle Pfade in absolute Form umzuwandeln, und überprüfen Sie, ob der resultierende Pfad innerhalb der erlaubten Verzeichnisse bleibt, bevor Sie Dateioperationen durchführen. Verwenden Sie einen Allowlist-Ansatz, bei dem nur bestimmte, vordefinierte Dateinamen oder Identifikatoren akzeptiert werden, anstatt beliebige Pfade. Stellen Sie die Anwendung mit minimalen Dateisystemberechtigungen bereit und erwägen Sie die Verwendung von Chroot-Jails oder Containern, um den zugänglichen Dateisystembereich als Defense-in-Depth zu begrenzen.

Häufige Auswirkungen

AuswirkungDetails
VertraulichkeitBereich: Vertraulichkeit

Angreifer können auf sensible Dateien außerhalb des beabsichtigten Verzeichnisses zugreifen, indem sie "../filedir"-Muster verwenden, wodurch Konfigurationsdateien, Anmeldedaten, Quellcode und Systeminformationen offengelegt werden.
IntegritätBereich: Integrität

Wenn Schreiboperationen Traversal-Sequenzen akzeptieren, können Angreifer Dateien an unbeabsichtigten Orten modifizieren oder erstellen, potenziell bösartigen Code einschleusen oder Konfigurationen ändern.
VerfügbarkeitBereich: Verfügbarkeit

Kritische System- oder Anwendungsdateien könnten durch Path Traversal überschrieben oder gelöscht werden, was zu Dienstunterbrechungen oder Systemausfällen führt.
ZugriffskontrolleBereich: Zugriffskontrolle

Der Zugriff auf Anmeldedatendateien oder Authentifizierungsdaten über Path Traversal kann zu Privilegieneskalation und unbefugtem Zugriff auf geschützte Systeme führen.

Beispielcode + Lösungscode

Das folgende Beispiel zeigt eine anfällige C-Anwendung, die Dateien basierend auf Benutzereingaben liest:

Anfälliger Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BASE_DIR "/var/www/documents/"
#define MAX_PATH 512

void read_document(const char *filename) {
    char filepath[MAX_PATH];
    FILE *file;
    char buffer[1024];

    // ANFÄLLIG: Direkte Verkettung ohne Validierung
    snprintf(filepath, MAX_PATH, "%s%s", BASE_DIR, filename);

    // Angreifer kann verwenden: ../../../etc/passwd
    file = fopen(filepath, "r");
    if (file == NULL) {
        printf("Fehler: Datei nicht gefunden\n");
        return;
    }

    while (fgets(buffer, sizeof(buffer), file) != NULL) {
        printf("%s", buffer);
    }

    fclose(file);
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printf("Verwendung: %s <dateiname>\n", argv[0]);
        return 1;
    }

    read_document(argv[1]);
    return 0;
}

Dieser Code verkettet Benutzereingaben direkt mit dem Basisverzeichnispfad. Ein Angreifer, der "../../../etc/passwd" angibt, veranlasst die Anwendung, /var/www/documents/../../../etc/passwd zu lesen, was zu /etc/passwd aufgelöst wird.

Korrigierter Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <errno.h>

#define BASE_DIR "/var/www/documents"
#define MAX_PATH PATH_MAX

int contains_traversal(const char *input) {
    // Auf verschiedene Traversal-Muster prüfen
    if (strstr(input, "..") != NULL) return 1;
    if (strstr(input, "./") != NULL) return 1;
    if (strchr(input, '\0') != input + strlen(input)) return 1; // Null-Byte
    return 0;
}

int is_safe_path(const char *base, const char *filepath) {
    char resolved_base[MAX_PATH];
    char resolved_path[MAX_PATH];

    // Beide Pfade in kanonische Form auflösen
    if (realpath(base, resolved_base) == NULL) {
        return 0;
    }

    if (realpath(filepath, resolved_path) == NULL) {
        return 0;
    }

    // Überprüfen, dass der aufgelöste Pfad mit dem Basisverzeichnis beginnt
    size_t base_len = strlen(resolved_base);
    if (strncmp(resolved_path, resolved_base, base_len) != 0) {
        return 0;
    }

    // Sicherstellen, dass es tatsächlich ein Unterverzeichnis ist (nicht nur Präfix-Übereinstimmung)
    if (resolved_path[base_len] != '/' && resolved_path[base_len] != '\0') {
        return 0;
    }

    return 1;
}

void read_document(const char *filename) {
    char filepath[MAX_PATH];
    FILE *file;
    char buffer[1024];

    // Erste Verteidigungslinie: offensichtliche Traversal-Versuche ablehnen
    if (contains_traversal(filename)) {
        fprintf(stderr, "Fehler: Ungültiger Dateiname (Traversal erkannt)\n");
        return;
    }

    // Validieren, dass Dateiname nur erlaubte Zeichen enthält
    for (size_t i = 0; i < strlen(filename); i++) {
        char c = filename[i];
        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
              (c >= '0' && c <= '9') || c == '.' || c == '_' || c == '-')) {
            fprintf(stderr, "Fehler: Ungültiges Zeichen im Dateinamen\n");
            return;
        }
    }

    snprintf(filepath, MAX_PATH, "%s/%s", BASE_DIR, filename);

    // Kritisch: Überprüfen, dass aufgelöster Pfad im Basisverzeichnis liegt
    if (!is_safe_path(BASE_DIR, filepath)) {
        fprintf(stderr, "Fehler: Zugriff verweigert (Pfad außerhalb des erlaubten Verzeichnisses)\n");
        return;
    }

    file = fopen(filepath, "r");
    if (file == NULL) {
        fprintf(stderr, "Fehler: Datei nicht gefunden\n");
        return;
    }

    while (fgets(buffer, sizeof(buffer), file) != NULL) {
        printf("%s", buffer);
    }

    fclose(file);
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printf("Verwendung: %s <dateiname>\n", argv[0]);
        return 1;
    }

    read_document(argv[1]);
    return 0;
}

Der korrigierte Code implementiert mehrere Verteidigungsschichten: explizite Prüfung auf Traversal-Sequenzen wie "..", Zeichen-Allowlisting für Dateinamen und kanonische Pfadauflösung mit realpath(), um zu überprüfen, dass der endgültige aufgelöste Pfad innerhalb des beabsichtigten Basisverzeichnisses bleibt.

Ausgenutzt in der Praxis

Apache HTTP Server Path Traversal (Global, 2021)

CVE-2021-41773 betraf Apache HTTP Server 2.4.49, bei dem Path Traversal mit "../"-Sequenzen mit URL-Codierung (%2e) Angreifern den Zugriff auf Dateien außerhalb des Document Root ermöglichte. Wenn CGI-Skripte aktiviert waren, ermöglichte dies auch Remote-Code-Ausführung. Die Schwachstelle wurde unmittelbar nach der Offenlegung aktiv ausgenutzt und betraf Tausende von Servern, bevor Patches angewendet werden könnten. Ein nachfolgender Fix in 2.4.50 erwies sich als unvollständig, was zu CVE-2021-42013 führte.

GitLab Arbitrary File Read (GitLab-Instanzen, 2023)

CVE-2023-2825 in GitLab CE/EE Versionen 16.0.0 ermöglichte es nicht authentifizierten Angreifern, beliebige Dateien auf dem Server über eine Path-Traversal-Schwachstelle zu lesen. Angreifer könnten "../"-Sequenzen verwenden, um beabsichtigte Verzeichnisse zu verlassen und auf sensible Konfigurationsdateien zuzugreifen, potenziell einschließlich GitLabs Secrets-Datei mit Verschlüsselungsschlüsseln und Datenbankanmeldedaten. Die Schwachstelle betraf die Handhabung von Anhängen in öffentlichen Projekten.

Zyxel Firewall Path Traversal (Netzwerkinfrastruktur, 2022)

CVE-2022-30525 betraf Zyxel-Firewalls, bei denen Path Traversal über "../"-Sequenzen in Kombination mit Command-Injection nicht authentifizierten entfernten Angreifern Code-Ausführung ermöglichte. Die Schwachstelle betraf mehrere Zyxel-Firewall-Produkte, die zum Schutz von Unternehmensnetzwerken verwendet werden, wobei aktive Ausnutzung beobachtet wurde, die auf Netzwerk-Perimeter-Geräte abzielte.

Tools zum Testen/Ausnutzen

  • Burp Suite — umfassendes Web-Sicherheitstest-Tool mit integrierten Path-Traversal-Payloads einschließlich "../filedir"-Mustern und verschiedenen Codierungstechniken zur Umgehung von Filtern.

  • dotdotpwn — spezialisierter Directory-Traversal-Fuzzer, der zahlreiche "../"-Payload-Variationen testet, einschließlich codierter Formen, tiefer Traversal-Tiefen und plattformspezifischer Sequenzen.

  • FFUF — schneller Web-Fuzzer, der mit Path-Traversal-Wortlisten verwendet werden kann, um systematisch auf "../filedir"-Stil-Schwachstellen über mehrere Parameter hinweg zu testen.

CVE-Beispiele

  • CVE-2021-41773 — Apache HTTP Server Path Traversal über codierte "../"-Sequenzen ermöglicht Dateizugriff und potenzielle RCE.

  • CVE-2023-2825 — GitLab Arbitrary File Read durch "../" Path Traversal in der Anhangbehandlung.

  • CVE-2022-30525 — Zyxel Firewall Path Traversal kombiniert mit Command-Injection für nicht authentifizierte RCE.

  • CVE-2020-5410 — Spring Cloud Config Server Path Traversal über "../" ermöglicht Zugriff auf beliebige Dateien.

Referenzen

  1. MITRE. "CWE-24: Path Traversal: '../filedir'." Common Weakness Enumeration. https://cwe.mitre.org/data/definitions/24.html

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

  3. PortSwigger. "File path traversal." Web Security Academy. https://portswigger.net/web-security/file-path-traversal

  4. Checkmarx. "What is Path Traversal?" https://checkmarx.com/glossary/path-traversal/