Dateien oder Verzeichnisse für externe Parteien zugänglich

Beschreibung

Dateien oder Verzeichnisse für externe Parteien zugänglich ist eine Schwachstelle, bei der ein Produkt Dateien oder Verzeichnisse für unbefugte Akteure zugänglich macht, obwohl sie es nicht sein sollten. Dies tritt auf, wenn sensible Dateien an öffentlich zugänglichen Orten ohne ordnungsgemäße Zugriffskontrollen gespeichert werden. Häufige Szenarien umfassen Webserver, die sensible Dateien unter dem Document-Root speichern, Cloud-Storage-Buckets mit Fehlkonfiguration für öffentlichen Zugriff, Archivdateien, die versehentlich sensible Inhalte enthalten, und Backup-Dateien in zugänglichen Verzeichnissen.

Risiko

Exponierte Dateien und Verzeichnisse erzeugen kritische Datenoffenlegungsrisiken. Konfigurationsdateien können Datenbank-Anmeldeinformationen, API-Schlüssel und Verschlüsselungsgeheimnisse enthalten. Quellcode-Offenlegung enthüllt Anwendungslogik und potenzielle Schwachstellen. Datenbank-Backups enthalten alle Benutzerdaten und Authentifizierungsinformationen. Log-Dateien können sensible Benutzeraktionen, Session-Tokens oder Fehlerdetails enthalten. Git-Repositories exponieren die vollständige Versionshistorie einschließlich gelöschter Geheimnisse. Cloud-Storage-Fehlkonfigurationen haben zu massiven Datenschutzverletzungen geführt.

Lösung

Speichern Sie sensible Dateien außerhalb webzugänglicher Verzeichnisse. Konfigurieren Sie Webserver, um den Zugriff auf sensible Dateitypen und Verzeichnisse zu verweigern. Verwenden Sie Cloud-Anbieterkontrollen, um öffentlichen Zugriff auf Storage-Buckets zu deaktivieren. Implementieren Sie ordnungsgemäße Zugriffskontrollen mit Authentifizierungsanforderungen. Führen Sie regelmäßig Audits von Dateiberechtigungen und Verzeichniszugriffskonfigurationen durch. Entfernen oder verschieben Sie Backup-Dateien, Log-Dateien und Entwicklungsartefakte aus der Produktion.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Vertraulichkeit Dateien oder Verzeichnisse lesen - Unbefugter Zugriff auf sensible Dateien einschließlich Konfiguration, Quellcode, Backups und Benutzerdaten.
Integrität	Bereich: Integrität Dateien oder Verzeichnisse ändern - In manchen Fällen ermöglichen fehlkonfigurierte Berechtigungen das Schreiben oder Ändern von Dateien.

Beispielcode

Verwundbarer Code

# Verwundbar: Apache-Konfiguration exponiert sensible Dateien
<VirtualHost *:80>
    ServerName example.com
    DocumentRoot /var/www/html

    # Verwundbar: Keine Einschränkungen für sensible Dateien
    # Diese Dateien sind für jeden zugänglich:
    # - /var/www/html/.git/          (Git-Repository)
    # - /var/www/html/backup/        (Backups)
    # - /var/www/html/.env           (Umgebungsvariablen)
    # - /var/www/html/config.php     (Konfiguration)
    # - /var/www/html/database.sql   (Datenbank-Dump)

    <Directory /var/www/html>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

# Verwundbar: AWS S3-Bucket mit öffentlichem Zugriff
aws s3api create-bucket \
    --bucket my-company-backups \
    --region us-east-1

# Verwundbar: Öffentlichen Lese-ACL setzen
aws s3api put-bucket-acl \
    --bucket my-company-backups \
    --acl public-read

# Verwundbar: Policy erlaubt öffentlichen Zugriff
aws s3api put-bucket-policy --bucket my-company-backups --policy '{
    "Version": "2012-10-17",
    "Statement": [{
        "Effect": "Allow",
        "Principal": "*",
        "Action": "s3:GetObject",
        "Resource": "arn:aws:s3:::my-company-backups/*"
    }]
}'
# Jeder kann zugreifen: https://my-company-backups.s3.amazonaws.com/database-backup.sql

<?php
// Verwundbar: Sensible Dateien im Web-Root speichern
class VerwundbarerDateiSpeicher {
    // Verwundbar: Speicherung in webzugänglichem Verzeichnis
    private $uploadDir = '/var/www/html/uploads/';
    private $backupDir = '/var/www/html/backup/';

    public function saveUpload($file, $userId) {
        // Verwundbar: Keine Zugriffskontrolle
        $filename = $file['name'];
        move_uploaded_file($file['tmp_name'], $this->uploadDir . $filename);
        return '/uploads/' . $filename;  // Für jeden zugänglich!
    }

    public function createBackup() {
        // Verwundbar: Datenbank-Backup im Web-Root
        $backupFile = $this->backupDir . 'db_' . date('Y-m-d') . '.sql';
        exec("mysqldump -u root -pPassword123 mydb > $backupFile");
        return $backupFile;  // Zugänglich unter /backup/db_2024-01-15.sql
    }
}
?>

Lösungscode

# Behoben: Apache-Konfiguration schützt sensible Dateien
<VirtualHost *:80>
    ServerName example.com
    DocumentRoot /var/www/html/public  # Behoben: Nur public-Ordner ist Web-Root

    # Behoben: Zugriff auf sensible Dateimuster verweigern
    <FilesMatch "\.(sql|bak|old|backup|log|ini|conf|env|config|git)$">
        Require all denied
    </FilesMatch>

    # Behoben: Versteckte Dateien und Verzeichnisse blockieren
    <DirectoryMatch "/\.">
        Require all denied
    </DirectoryMatch>

    # Behoben: Sensible Verzeichnisse blockieren
    <DirectoryMatch "/(\.git|\.svn|backup|logs|config)">
        Require all denied
    </DirectoryMatch>
</VirtualHost>

# Behobene Verzeichnisstruktur:
# /var/www/
# ├── html/
# │   └── public/           <- Nur dies ist webzugänglich
# │       ├── index.php
# │       └── css/
# ├── config/               <- Außerhalb des Web-Root
# ├── storage/              <- Außerhalb des Web-Root
# └── backup/               <- Außerhalb des Web-Root

# Behoben: AWS S3-Bucket mit privatem Zugriff
aws s3api create-bucket \
    --bucket my-company-backups \
    --region us-east-1

# Behoben: Gesamten öffentlichen Zugriff blockieren
aws s3api put-public-access-block \
    --bucket my-company-backups \
    --public-access-block-configuration \
    "BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true"

# Behoben: Private Bucket-Policy nur für authentifizierten Zugriff
aws s3api put-bucket-policy --bucket my-company-backups --policy '{
    "Version": "2012-10-17",
    "Statement": [{
        "Effect": "Allow",
        "Principal": {"AWS": "arn:aws:iam::123456789012:role/BackupServiceRole"},
        "Action": ["s3:GetObject", "s3:PutObject"],
        "Resource": "arn:aws:s3:::my-company-backups/*"
    }]
}'

<?php
// Behoben: Sichere Dateispeicherung außerhalb des Web-Root
class SichererDateiSpeicher {
    // Behoben: Dateien außerhalb des Web-Root speichern
    private $baseStoragePath = '/var/www/storage/';

    public function saveUpload(array $file, int $userId): string {
        // Behoben: Dateityp validieren
        $allowedTypes = ['image/jpeg', 'image/png', 'application/pdf'];
        if (!in_array($file['type'], $allowedTypes)) {
            throw new InvalidArgumentException('Dateityp nicht erlaubt');
        }

        // Behoben: Sicheren Dateinamen generieren
        $extension = pathinfo($file['name'], PATHINFO_EXTENSION);
        $filename = bin2hex(random_bytes(16)) . '.' . $extension;

        // Behoben: In benutzer-spezifischem Verzeichnis außerhalb Web-Root speichern
        $userDir = $this->baseStoragePath . 'uploads/' . $userId . '/';
        if (!is_dir($userDir)) mkdir($userDir, 0750, true);

        move_uploaded_file($file['tmp_name'], $userDir . $filename);
        return $filename;  // Nur Identifier zurückgeben, nicht Pfad
    }

    public function getFile(string $filename, int $requestingUserId): ?string {
        // Behoben: Zugriffskontrollprüfung
        $filePath = $this->baseStoragePath . 'uploads/' . $requestingUserId . '/' . basename($filename);
        
        $realPath = realpath($filePath);
        if ($realPath === false || strpos($realPath, realpath($this->baseStoragePath)) !== 0) {
            return null;  // Pfaddurchlauf-Versuch
        }
        return $filePath;
    }

    public function createBackup(): string {
        // Behoben: Backup außerhalb Web-Root mit eingeschränkten Berechtigungen
        $backupFile = $this->baseStoragePath . 'backups/db_' . date('Y-m-d_His') . '.sql.gz';
        
        $dbUser = getenv('DB_USER');
        $dbPass = getenv('DB_PASS');
        $dbName = getenv('DB_NAME');

        exec("mysqldump -u " . escapeshellarg($dbUser) .
             " -p" . escapeshellarg($dbPass) . " " .
             escapeshellarg($dbName) . " | gzip > " .
             escapeshellarg($backupFile));

        chmod($backupFile, 0600);  // Nur Eigentümer kann lesen
        return $backupFile;
    }
}
?>

CVE-Beispiele

CVE-2019-5420: Rails Development Mode mit exponierten Geheimnissen ermöglichte Remote-Code-Ausführung.
CVE-2017-9841: PHPUnit hatte RCE-Schwachstelle durch exponierte Test-Skripte.
CVE-2023-34362: MOVEit Transfer hatte SQL-Injection durch öffentlich zugänglichen Endpunkt.

Referenzen

MITRE Corporation. "CWE-552: Files or Directories Accessible to External Parties." https://cwe.mitre.org/data/definitions/552.html
OWASP. "OWASP Top Ten 2021 - A05:2021 Security Misconfiguration."
AWS. "Blocking public access to your Amazon S3 storage."