Zurück zur Schwachstellen-Datenbank

Unsachgemäße Beibehaltung von Berechtigungen

Beschreibung

Unsachgemäße Beibehaltung von Berechtigungen ist eine Schwachstelle, die auftritt, wenn ein Produkt Berechtigungen beim Kopieren, Wiederherstellen oder Teilen von Objekten nicht beibehält oder falsch beibehält, was dazu führen kann, dass sie weniger restriktive Berechtigungen als beabsichtigt haben. Anders als CWE-278, das sich auf das Erben unsicherer Berechtigungen von Quellobjekten konzentriert, betrifft diese Schwäche das Versäumnis, beabsichtigte Sicherheitseinstellungen während Operationen aufrechtzuerhalten, die sie beibehalten sollten. Dies kann während Backup-Wiederherstellung, Datei-Klonen, Datenexport/-import oder Freigabeoperationen auftreten, bei denen die Zielobjekte mit anderen (typischerweise schwächeren) Berechtigungen als die Quelle enden.

Risiko

Unsachgemäße Berechtigungsbeibehaltung erzeugt Sicherheitsschwachstellen, indem Zugriffskontrollen während häufiger Operationen stillschweigend degradiert werden. Backup-Wiederherstellungen, die ACLs nicht ordnungsgemäß beibehalten, können zuvor geschützte Daten offenlegen. Datei-Klonoperationen, die Berechtigungen auf Defaults zurücksetzen, können sensible Dateien welt-lesbar machen. Exportoperationen, die Berechtigungsmetadaten entfernen, lassen exportierte Daten in Zielsystemen ungeschützt. Das Risiko wird verstärkt, weil Administratoren und Benutzer typischerweise erwarten, dass diese Operationen Sicherheitseinstellungen beibehalten, und möglicherweise Berechtigungen nach Abschluss nicht verifizieren. Symlink-Angriffe während Backup-Wiederherstellung können Berechtigungszuweisungen weiter korrumpieren. Systeme mit komplexen ACL-Anforderungen sind besonders anfällig, da einfaches Berechtigungskopieren erweiterte Attribute verlieren kann.

Lösung

Stellen Sie sicher, dass alle Kopier-, Backup-, Wiederherstellungs- und Freigabeoperationen vollständige Berechtigungsinformationen einschließlich Eigentümer, Gruppe, Standardberechtigungen, ACLs und erweiterter Attribute beibehalten. Verwenden Sie Backup- und Wiederherstellungstools, die alle Berechtigungsmetadaten für die Zielplattform ordnungsgemäß handhaben. Verifizieren Sie Berechtigungen nach Wiederherstellungs- oder Kopieroperationen, insbesondere für sicherheitskritische Dateien. Implementieren Sie Berechtigungsverifikation als Teil der Backup-Wiederherstellungsvalidierung. Wenn Sie Daten zwischen Systemen mit unterschiedlichen Berechtigungsmodellen exportieren, dokumentieren Sie die erwarteten Berechtigungen und stellen Sie Mechanismen bereit, um sie am Ziel anzuwenden. Für Operationen, bei denen Berechtigungen nicht beibehalten werden können, warnen Sie Benutzer und wenden Sie restriktive Standardberechtigungen an anstatt permissiver. Erwägen Sie die Verwendung unveränderlicher Backups, die Berechtigungsintegrität kryptografisch verifizieren.

Häufige Auswirkungen

AuswirkungDetails
Vertraulichkeit, IntegritätBereich: Vertraulichkeit, Integrität

Unbefugtes Lesen von Anwendungsdaten tritt auf, wenn kopierte oder wiederhergestellte Dateien permissivere Leseberechtigungen als Originale haben. Unbefugte Modifikation tritt auf, wenn Schreibberechtigungen nach Operationen, die sie beibehalten sollten, nicht ordnungsgemäß eingeschränkt werden.

Beispielcode

Anfälliger Code (Python)

Die folgenden Beispiele demonstrieren unsachgemäße Berechtigungsbeibehaltung:

# Anfällig: Backup-Wiederherstellung behält Berechtigungen nicht bei
import os
import shutil
import tarfile

class VulnerableBackupRestore:

    def restore_from_tar(self, archive_path, dest_dir):
        # Anfällig: extractall behält möglicherweise nicht alle Berechtigungen bei
        with tarfile.open(archive_path, 'r:gz') as tar:
            tar.extractall(dest_dir)
        # Berechtigungen können sich vom ursprünglichen Backup unterscheiden
        # ACLs und erweiterte Attribute können verloren gehen

    def copy_file_simple(self, source, dest):
        # Anfällig: shutil.copy behält Berechtigungen nicht bei
        shutil.copy(source, dest)
        # Zieldatei hat andere Berechtigungen als Quelle

    def clone_directory(self, source_dir, dest_dir):
        # Anfällig: copytree verwendet Standardberechtigungen für neue Dateien
        shutil.copytree(source_dir, dest_dir)
        # Wenn Quelle restriktive Berechtigungen hatte, werden sie möglicherweise nicht beibehalten

    def restore_with_symlink_vulnerability(self, backup_file, dest_path):
        # Anfällig: Symlink kann Wiederherstellung umleiten
        # Angreifer erstellt Symlink vor Wiederherstellung
        with open(dest_path, 'wb') as f:
            f.write(read_backup(backup_file))
        # Wenn dest_path ein Symlink ist, wird an falschen Ort geschrieben
        # Berechtigungen auf falsche Datei angewendet

// Anfällig: C-Dateikopie ohne Berechtigungsbeibehaltung
#include <stdio.h>
#include <sys/stat.h>

int vulnerable_copy_file(const char *source, const char *dest) {
    FILE *src = fopen(source, "rb");
    FILE *dst = fopen(dest, "wb");

    if (!src || !dst) return -1;

    char buffer[8192];
    size_t bytes;
    while ((bytes = fread(buffer, 1, sizeof(buffer), src)) > 0) {
        fwrite(buffer, 1, bytes, dst);
    }

    fclose(src);
    fclose(dst);

    // Anfällig: Zieldatei hat Standardberechtigungen (aus umask)
    // Quelldateiberechtigungen nicht beibehalten
    return 0;
}

int vulnerable_restore_backup(const char *backup, const char *dest) {
    // Anfällig: Behält ACLs nicht bei
    struct stat st;
    stat(backup, &st);

    // Kopiert nur Basisberechtigungen, nicht ACLs oder erweiterte Attribute
    copy_file_content(backup, dest);
    chmod(dest, st.st_mode);

    // Erweiterte ACLs und Capabilities gehen verloren
    return 0;
}

# Anfällig: Shell-Operationen verlieren Berechtigungen
#!/bin/bash

# Anfällig: cp ohne -p verliert Berechtigungen
cp /secure/sensitive.conf /backup/sensitive.conf
# Backup-Datei hat Standardberechtigungen

# Anfällig: tar behält möglicherweise keine erweiterten Attribute bei
tar -czf backup.tar.gz /secure/data/
# Wiederherstellung hat keine Original-ACLs

# Anfällig: rsync ohne ordnungsgemäße Flags
rsync /source/data/ /dest/data/
# Berechtigungen werden möglicherweise nicht beibehalten

Korrigierter Code (Python)

# Korrigiert: Ordnungsgemäße Berechtigungsbeibehaltung während Operationen
import os
import shutil
import tarfile
import stat

class SecureBackupRestore:

    def restore_from_tar(self, archive_path, dest_dir):
        # Verifizieren, dass Ziel keine Symlinks enthält, die umleiten könnten
        if os.path.exists(dest_dir):
            for root, dirs, files in os.walk(dest_dir):
                for name in dirs + files:
                    path = os.path.join(root, name)
                    if os.path.islink(path):
                        raise SecurityError(f"Symlink im Wiederherstellungspfad: {path}")

        with tarfile.open(archive_path, 'r:gz') as tar:
            # Auf Path Traversal und Symlink-Angriffe prüfen
            for member in tar.getmembers():
                if member.name.startswith('/') or '..' in member.name:
                    raise SecurityError(f"Unsicherer Pfad: {member.name}")
                if member.issym() or member.islnk():
                    # Symlinks sorgfältig behandeln
                    link_target = os.path.normpath(
                        os.path.join(dest_dir, member.linkname)
                    )
                    if not link_target.startswith(dest_dir):
                        raise SecurityError(f"Symlink-Escape: {member.name}")

            # Mit Berechtigungsbeibehaltung extrahieren
            tar.extractall(dest_dir, numeric_owner=True)

        # Verifizieren, dass Berechtigungen beibehalten wurden
        self.verify_permissions(archive_path, dest_dir)

    def copy_file_with_permissions(self, source, dest):
        # copy2 verwenden, das Berechtigungen und Metadaten beibehält
        shutil.copy2(source, dest)

        # Verifizieren, dass Berechtigungen übereinstimmen
        src_stat = os.stat(source)
        dst_stat = os.stat(dest)
        if src_stat.st_mode != dst_stat.st_mode:
            # Berechtigungen erzwingen wenn copy2 fehlschlug
            os.chmod(dest, src_stat.st_mode)

        # ACLs kopieren falls verfügbar (Linux)
        try:
            import posix1e
            acl = posix1e.ACL(file=source)
            acl.applyto(dest)
        except (ImportError, OSError):
            pass  # ACL-Unterstützung nicht verfügbar

    def clone_directory_securely(self, source_dir, dest_dir):
        # Ziel mit denselben Berechtigungen wie Quelle erstellen
        src_stat = os.stat(source_dir)

        def copy_function(src, dst):
            shutil.copy2(src, dst)
            # Auch erweiterte Attribute kopieren
            try:
                import xattr
                for attr in xattr.listxattr(src):
                    xattr.setxattr(dst, attr, xattr.getxattr(src, attr))
            except (ImportError, OSError):
                pass

        shutil.copytree(
            source_dir, dest_dir,
            copy_function=copy_function,
            dirs_exist_ok=False
        )

        # Verzeichnisberechtigungen verifizieren
        os.chmod(dest_dir, src_stat.st_mode)

    def verify_permissions(self, archive_path, dest_dir):
        """Verifizieren, dass wiederhergestellte Dateien korrekte Berechtigungen haben"""
        with tarfile.open(archive_path, 'r:gz') as tar:
            for member in tar.getmembers():
                dest_path = os.path.join(dest_dir, member.name)
                if os.path.exists(dest_path) and not os.path.islink(dest_path):
                    actual_mode = os.stat(dest_path).st_mode & 0o7777
                    expected_mode = member.mode & 0o7777
                    if actual_mode != expected_mode:
                        raise PermissionVerificationError(
                            f"Berechtigungsmismatch für {member.name}: "
                            f"erwartet {oct(expected_mode)}, erhalten {oct(actual_mode)}"
                        )

// Korrigiert: C-Dateikopie mit Berechtigungsbeibehaltung
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/xattr.h>
#include <sys/acl.h>

int secure_copy_file(const char *source, const char *dest) {
    struct stat st;
    if (stat(source, &st) != 0) {
        return -1;
    }

    // Quelle zum Lesen öffnen
    int src_fd = open(source, O_RDONLY);
    if (src_fd < 0) return -1;

    // Ziel mit Quellberechtigungen erstellen
    int dst_fd = open(dest, O_WRONLY | O_CREAT | O_TRUNC, st.st_mode);
    if (dst_fd < 0) {
        close(src_fd);
        return -1;
    }

    // Inhalt kopieren
    char buffer[8192];
    ssize_t bytes;
    while ((bytes = read(src_fd, buffer, sizeof(buffer))) > 0) {
        if (write(dst_fd, buffer, bytes) != bytes) {
            close(src_fd);
            close(dst_fd);
            return -1;
        }
    }

    close(src_fd);
    close(dst_fd);

    // Berechtigungen explizit setzen (falls umask die Erstellung beeinflusste)
    chmod(dest, st.st_mode);

    // Eigentum beibehalten (erfordert root)
    chown(dest, st.st_uid, st.st_gid);

    // ACLs kopieren
    acl_t acl = acl_get_file(source, ACL_TYPE_ACCESS);
    if (acl != NULL) {
        acl_set_file(dest, ACL_TYPE_ACCESS, acl);
        acl_free(acl);
    }

    // Erweiterte Attribute kopieren
    char xattr_list[1024];
    ssize_t list_len = listxattr(source, xattr_list, sizeof(xattr_list));
    if (list_len > 0) {
        char *name = xattr_list;
        while (name < xattr_list + list_len) {
            char value[1024];
            ssize_t value_len = getxattr(source, name, value, sizeof(value));
            if (value_len > 0) {
                setxattr(dest, name, value, value_len, 0);
            }
            name += strlen(name) + 1;
        }
    }

    return 0;
}

# Korrigiert: Shell-Operationen mit Berechtigungsbeibehaltung
#!/bin/bash

# Kopieren mit Berechtigungsbeibehaltung
cp -p /secure/sensitive.conf /backup/sensitive.conf

# Oder rsync mit vollständiger Beibehaltung verwenden
rsync -aAX /source/data/ /dest/data/
# -a: Archive-Modus (behält Berechtigungen, Eigentum, Zeitstempel bei)
# -A: ACLs beibehalten
# -X: Erweiterte Attribute beibehalten

# Tar mit erweiterten Attributen und ACLs
tar --xattrs --acls -czf backup.tar.gz /secure/data/

# Wiederherstellen mit Berechtigungen
tar --xattrs --acls -xzf backup.tar.gz -C /restore/

# Berechtigungen nach Wiederherstellung verifizieren
find /restore/ -exec stat -c '%a %n' {} \; > restored_perms.txt

Die Korrektur stellt sicher, dass alle Berechtigungsmetadaten (Basisberechtigungen, ACLs, erweiterte Attribute) während Kopier- und Wiederherstellungsoperationen beibehalten werden.

Ausgenutzt in der Praxis

Backup-Wiederherstellung ACL-Verlust (Unternehmensumgebungen, Fortlaufend)

Backup-Wiederherstellungen mit Tools, die ACLs nicht ordnungsgemäß beibehalten, haben zuvor geschützte Daten offengelegt. CVE-2002-2323 dokumentierte Backup-Wiederherstellung mit symbolischen Links, die zu falschen ACLs führte.

Datei-Klonen Berechtigungsdegradation (Unix-Systeme, Historisch)

CVE-2001-1515 dokumentierte Dateisystem-Vererbung, die unbeabsichtigte Berechtigungsänderungen während Kopieroperationen verursachte und Sicherheit auf geklonten Dateien schwächte.

Backup-Datei Standardberechtigungen (Verschiedene Anwendungen, Fortlaufend)

CVE-2005-1920 dokumentierte Backup-Dateien, die mit Standardberechtigungen erstellt wurden, die weniger restriktiv als Originale waren, wobei sensible Daten aus Backup-Operationen offengelegt wurden.

Tools zum Testen/Ausnutzen

  • getfacl/setfacl — Tools zum Anzeigen und Manipulieren von ACLs, um Beibehaltung zu verifizieren.

  • rsync — Dateisynchronisationstool mit Optionen für ACL- und erweiterte-Attribute-Beibehaltung.

  • tar mit ACL-Unterstützung — Archivtool mit Optionen zum Beibehalten erweiterter Attribute.

CVE-Beispiele

  • CVE-2002-2323 — Backup-Wiederherstellung mit symbolischen Links führte zu falschen ACLs.

  • CVE-2001-1515 — Dateisystem-Vererbung verursachte unbeabsichtigte Berechtigungsänderungen.

  • CVE-2005-1920 — Backup-Dateien mit Standardberechtigungen erstellt, die weniger restriktiv als Originale waren.

  • CVE-2001-0195 — Dateien wurden während Klonoperationen welt-lesbar.

Referenzen

  1. MITRE Corporation. "CWE-281: Improper Preservation of Permissions." Common Weakness Enumeration. https://cwe.mitre.org/data/definitions/281.html

  2. Linux man pages. "acl(5) - Access Control Lists." https://man7.org/linux/man-pages/man5/acl.5.html

  3. OWASP Foundation. "Broken Access Control." OWASP Top 10. https://owasp.org/Top10/A01_2021-Broken_Access_Control/