Offenlegung von Backup-Datei für unbefugte Kontrollsphäre

Beschreibung

Offenlegung von Backup-Datei für unbefugte Kontrollsphäre ist eine Schwachstelle, bei der eine Backup-Datei in einem Verzeichnis oder Archiv gespeichert wird, das für unbefugte Benutzer zugänglich ist und potenziell sensible Anwendungsdaten offenlegt. Backup-Dateien werden oft mit Erweiterungen wie .bak, .old, .~bk, .backup umbenannt oder enthalten Zeitstempel, um sie von Produktionsdateien zu unterscheiden. Wenn diese umbenannten Dateien im Webroot oder anderen zugänglichen Speicherorten verbleiben, können sie von Angreifern abgerufen werden. Solche Backup-Erstellung kann automatisch durch Webserver-Konfiguration, Editor-Verhalten oder manuell durch Administratoren bei der Wartung erfolgen.

Risiko

Backup-Dateien enthalten oft die gleichen sensiblen Informationen wie Produktionsdateien, umgehen aber Sicherheitskontrollen, die für die Originaldateien konzipiert wurden. PHP-Quelldateien, die in .php.bak umbenannt werden, können als Klartext bereitgestellt werden und Quellcode einschließlich Datenbank-Anmeldedaten, API-Schlüssel und Geschäftslogik offenlegen. Konfigurations-Backups können Klartext-Passwörter enthalten. Datenbank-Dump-Backups legen komplette Datensätze offen. Angreifer scannen routinemäßig nach Backup-Dateimustern als Teil der Aufklärung. Selbst partielle Backups können Anwendungsarchitektur, Parameterformate und Sicherheitsmechanismen offenbaren, die weitere Angriffe unterstützen.

Lösung

Etablieren und erzwingen Sie Sicherheitsrichtlinien, die das Speichern von Backup-Dateien in web-zugänglichen Verzeichnissen verbieten. Konfigurieren Sie Webserver, um den Zugriff auf gängige Backup-Dateiendungen zu blockieren. Implementieren Sie automatisierte Deployment-Prozesse, die keine Backup-Dateien erstellen. Verwenden Sie ordnungsgemäße Versionskontrolle anstelle von Backup-Kopien. Speichern Sie notwendige Backups an sicheren, nicht web-zugänglichen Speicherorten mit angemessenen Zugriffskontrollen. Konfigurieren Sie Editoren und IDEs, um Backup-Dateien außerhalb des Projektverzeichnisses zu speichern. Scannen Sie regelmäßig nach Backup-Dateien und entfernen Sie sie aus Produktionssystemen. Schließen Sie Backup-Dateiprüfungen in Sicherheitstests und Deployment-Verifikation ein.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Vertraulichkeit Anwendungsdaten lesen - Angreifer, die Backup-Dateien abrufen, erhalten Zugriff auf alle enthaltenen Informationen, einschließlich Quellcode, Datenbank-Anmeldedaten, API-Schlüssel, Konfigurationsdetails und architektonische Informationen über die Anwendung.

Beispielcode

Verwundbare Konfiguration

# Verwundbar: Backup-Dateien im Webroot
$ ls -la /var/www/html/
-rw-r--r-- 1 www-data www-data 5120 Jan 15 10:00 config.php
-rw-r--r-- 1 www-data www-data 5120 Jan 14 09:00 config.php.bak
-rw-r--r-- 1 www-data www-data 5120 Jan 13 08:00 config.php.old
-rw-r--r-- 1 www-data www-data 5120 Jan 12 07:00 config.php~
-rw-r--r-- 1 www-data www-data 5120 Jan 11 06:00 config.php.2024-01-11
-rw-r--r-- 1 www-data www-data 5120 Jan 10 05:00 config.php.orig
-rw-r--r-- 1 www-data www-data 5120 Jan 09 04:00 .config.php.swp

# Alle diese Backup-Dateien sind web-zugänglich!
# config.php wird als PHP ausgeführt, aber Backups als Klartext bereitgestellt

<?php
// /var/www/html/config.php - normale Ausführung als PHP
// /var/www/html/config.php.bak - wird als KLARTEXT bereitgestellt!

$db_host = 'localhost';
$db_user = 'admin';
$db_pass = 'super_secret_password_123';  // Im Backup offengelegt!
$db_name = 'production_db';

$api_key = 'sk_live_abcdef123456789';    // API-Schlüssel offengelegt!
$encryption_key = 'aes-256-encryption-key'; // Verschlüsselungsschlüssel offengelegt!

// Angreifer greift zu: http://example.com/config.php.bak
// Und sieht alle diese Anmeldedaten im Klartext!
?>

# Verwundbar: Editor-Backup-Dateien
# vim erstellt .swp-Dateien
# emacs erstellt ~-Dateien
# Viele Editoren erstellen .bak-Dateien

# Nach Bearbeitung von /var/www/html/database.php mit vim:
$ ls -la /var/www/html/
-rw-r--r-- 1 dev dev 1024 Jan 15 10:00 database.php
-rw-r--r-- 1 dev dev 4096 Jan 15 10:00 .database.php.swp  # Vim-Swap
-rw-r--r-- 1 dev dev 1024 Jan 15 10:00 database.php~      # Vim-Backup

# Verwundbar: Admin erstellt Backup vor Änderungen
$ ssh admin@server
$ cd /var/www/html
$ cp application.conf application.conf.backup  # Schlechte Praxis!
$ cp index.php index.php.old                   # Schlechte Praxis!

# Verwundbar: tar-Backup im Webroot
$ tar czf backup.tar.gz /var/www/html/
$ mv backup.tar.gz /var/www/html/             # Gesamte Seite offengelegt!

# Verwundbar: SQL-Dump im Webroot
$ mysqldump mydb > /var/www/html/backup.sql   # Datenbank offengelegt!

Behobene Konfiguration

# Behoben: Backup-Dateien aus Webroot entfernen
#!/bin/bash

# Gängige Backup-Dateimuster finden und entfernen
find /var/www/html -type f \( \
    -name "*.bak" -o \
    -name "*.backup" -o \
    -name "*.old" -o \
    -name "*~" -o \
    -name "*.orig" -o \
    -name "*.swp" -o \
    -name ".*.swp" -o \
    -name "*.swo" -o \
    -name "*.save" -o \
    -name "*.sql" -o \
    -name "*.tar" -o \
    -name "*.tar.gz" -o \
    -name "*.zip" \
\) -delete

echo "Backup-Dateien aus Webroot entfernt"

# Behoben: Apache blockiert Backup-Dateien
<VirtualHost *:80>
    DocumentRoot /var/www/html

    # Behoben: Gängige Backup-Erweiterungen blockieren
    <FilesMatch "\.(bak|backup|old|orig|save|swp|swo|tmp)$">
        Require all denied
    </FilesMatch>

    # Behoben: Dateien mit Backup-Mustern blockieren
    <FilesMatch "~$">
        Require all denied
    </FilesMatch>

    # Behoben: Versteckte Swap-Dateien blockieren
    <FilesMatch "^\.[^.]+\.sw[op]$">
        Require all denied
    </FilesMatch>

    # Behoben: Archivdateien blockieren
    <FilesMatch "\.(tar|tar\.gz|tgz|zip|rar|7z|sql|dump)$">
        Require all denied
    </FilesMatch>

    # Behoben: PHP-Dateien mit Backup-Erweiterungen blockieren
    <FilesMatch "\.php\.(bak|backup|old|orig|~)$">
        Require all denied
    </FilesMatch>
</VirtualHost>

# Behoben: Nginx blockiert Backup-Dateien
server {
    listen 80;
    root /var/www/html;

    # Behoben: Gängige Backup-Erweiterungen blockieren
    location ~* \.(bak|backup|old|orig|save|swp|swo|tmp)$ {
        deny all;
        return 404;
    }

    # Behoben: Tilde-Backup-Dateien blockieren
    location ~ ~$ {
        deny all;
        return 404;
    }

    # Behoben: Versteckte Swap-Dateien blockieren
    location ~ /\.[^/]+\.sw[op]$ {
        deny all;
        return 404;
    }

    # Behoben: Archivdateien blockieren
    location ~* \.(tar|tar\.gz|tgz|zip|rar|7z|sql|dump)$ {
        deny all;
        return 404;
    }

    # Behoben: PHP-Backup-Dateien blockieren
    location ~* \.php\.(bak|backup|old|orig|~)$ {
        deny all;
        return 404;
    }

    # PHP-Ausführung
    location ~ \.php$ {
        include fastcgi_params;
        fastcgi_pass unix:/var/run/php-fpm.sock;
    }
}

# Behoben: Ordnungsgemäße Backup-Prozeduren (außerhalb Webroot)
#!/bin/bash

# Behoben: Backups an sicherem Speicherort speichern
BACKUP_DIR="/var/backups/webapp"
mkdir -p "$BACKUP_DIR"
chmod 700 "$BACKUP_DIR"

# Behoben: Backup an sicherem Speicherort, nicht Webroot
tar czf "$BACKUP_DIR/webapp-$(date +%Y%m%d).tar.gz" \
    --exclude='*.log' \
    /var/www/html/

# Behoben: Datenbank-Backup an sicherem Speicherort
mysqldump mydb | gzip > "$BACKUP_DIR/db-$(date +%Y%m%d).sql.gz"
chmod 600 "$BACKUP_DIR"/*.gz

# Behoben: Alte Backups rotieren
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +30 -delete
find "$BACKUP_DIR" -name "*.sql.gz" -mtime +30 -delete

# Behoben: Deployment-Skript mit Backup-Datei-Erkennung
import os
import sys
import fnmatch

BACKUP_PATTERNS = [
    '*.bak', '*.backup', '*.old', '*.orig', '*.save',
    '*.swp', '*.swo', '*~', '*.tmp',
    '*.sql', '*.dump', '*.tar', '*.tar.gz', '*.zip',
    '.*.swp', '.*.swo'
]

def find_backup_files(directory):
    """Backup-Dateien finden, die nicht deployed werden sollten."""
    backup_files = []

    for root, dirs, files in os.walk(directory):
        # Versteckte Verzeichnisse überspringen
        dirs[:] = [d for d in dirs if not d.startswith('.')]

        for pattern in BACKUP_PATTERNS:
            for filename in fnmatch.filter(files, pattern):
                backup_files.append(os.path.join(root, filename))

    return backup_files

def pre_deployment_check(webroot):
    """Vor Deployment auf Backup-Dateien prüfen."""
    backups = find_backup_files(webroot)

    if backups:
        print("FEHLER: Backup-Dateien im Deployment gefunden:")
        for f in backups:
            print(f"  - {f}")
        print("\nEntfernen Sie diese Dateien vor dem Deployment!")
        return False

    print("OK: Keine Backup-Dateien gefunden")
    return True

if __name__ == '__main__':
    webroot = sys.argv[1] if len(sys.argv) > 1 else '/var/www/html'
    if not pre_deployment_check(webroot):
        sys.exit(1)

CVE-Beispiele

Keine spezifischen CVEs sind in der MITRE-Datenbank für dieses CWE gelistet. Das Schwachstellenmuster ist jedoch extrem verbreitet:

Backup-Datei-Offenlegung ist ein häufiger Fund in Penetrationstests
Teil des OWASP Testing Guide für Sicherheitsfehlkonfiguration
Häufig in Bug-Bounty-Programmen

Referenzen

MITRE. "CWE-530: Exposure of Backup File to an Unauthorized Control Sphere." https://cwe.mitre.org/data/definitions/530.html
OWASP. "Testing for Backup Files (WSTG-CONF-04)."
OWASP Top Ten. "A05:2021 - Security Misconfiguration."