Fehlerhafte Berechtigungszuweisung für kritische Ressourcen

Beschreibung

Fehlerhafte Berechtigungszuweisung für kritische Ressourcen tritt auf, wenn ein Produkt Berechtigungen für eine sicherheitskritische Ressource so festlegt, dass diese Ressource von unbeabsichtigten Akteuren gelesen oder modifiziert werden kann. Kritische Ressourcen umfassen Konfigurationsdateien, ausführbare Dateien, Verschlüsselungsschlüssel, Anmeldedatenspeicher, Log-Dateien und Datenbankdateien. Wenn diese Ressourcen zu permissive Zugriffsrechte haben, können Angreifer mit eingeschränktem Zugriff auf ein System Privilegien eskalieren, Anmeldedaten stehlen, Anwendungsverhalten modifizieren oder auf sensible Daten zugreifen. Dies ist besonders gefährlich für Ressourcen, die mit erhöhten Privilegien ausgeführt werden oder sensible Informationen enthalten.

Risiko

Fehlerhafte Berechtigungen werden konsistent in den CWE Top 25 der gefährlichsten Software-Schwachstellen gelistet. CVE-2025-14979 in AirVPN Eddie für macOS legt XPC-Dienste ohne ordnungsgemäße Zugriffsbeschränkung offen und ermöglicht Privilegieneskalation zu Root ohne Authentifizierung. CVE-2025-2947 in IBM i ermöglicht entfernten privilegierten Benutzern die Eskalation zu Root durch falsches Profil-Swapping. Kaspersky Security Center (CVSS 7.1) hatte schlechtes Berechtigungsmanagement bei gemeinsamen Konfigurationsressourcen. Ähnliche Schwachstellen betreffen Apache Hive, TeamViewer und Siemens SIRIUS Sicherheitsrelais. Fehlerhafte Berechtigungen ermöglichen oft vollständige Systemkompromittierung von niedrig-privilegierten Ausgangspositionen.

Lösung

Wenden Sie das Prinzip der geringsten Privilegien an - Ressourcen sollten nur für Akteure zugänglich sein, die sie unbedingt benötigen. Setzen Sie restriktive Standardberechtigungen für neue Dateien und Verzeichnisse. Verwenden Sie ordnungsgemäße umask-Werte. Für sensible Dateien (Anmeldedaten, Schlüssel, Konfigurationen) beschränken Sie den Zugriff auf nur den Eigentümer (0600/0700). Prüfen Sie Berechtigungen während der Bereitstellung und regelmäßig danach. Verwenden Sie Dateisystem-ACLs für feinkörnige Kontrolle. Stellen Sie sicher, dass installierte Software keine weltweit beschreibbaren Dateien erstellt. Implementieren Sie ordnungsgemäße Gruppenmitgliedschaft für gemeinsame Ressourcen. Verifizieren Sie Berechtigungen nach Software-Updates.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Informationspreisgabe Sensible Dateien wie Anmeldedaten und Verschlüsselungsschlüssel können von nicht autorisierten Benutzern gelesen werden.
Integrität	Bereich: Konfigurationsmanipulation Angreifer können Konfigurationsdateien, ausführbare Dateien oder andere kritische Ressourcen modifizieren.
Zugriffskontrolle	Bereich: Privilegieneskalation Modifikation privilegierter ausführbarer Dateien oder Dienste ermöglicht Eskalation zu höheren Privilegiestufen.

Beispielcode + Lösungscode

Verwundbarer Code

# VERWUNDBAR: Weltweit beschreibbare Konfigurationsdatei
import os

def create_config():
    config_path = '/etc/myapp/config.json'

    with open(config_path, 'w') as f:
        f.write(json.dumps(config_data))

    # Weltweit les- und beschreibbar - jeder kann modifizieren!
    os.chmod(config_path, 0o666)

# VERWUNDBAR: Anmeldedatendatei mit falschen Berechtigungen
def save_credentials(username, password):
    cred_file = '/app/credentials.txt'

    with open(cred_file, 'w') as f:
        f.write(f"{username}:{password}")

    # Standard-umask kann Datei für andere lesbar lassen

// VERWUNDBAR: Log-Datei mit sensiblen Daten, falsche Berechtigungen
import java.io.File;
import java.io.FileWriter;

public class Logger {
    private File logFile;

    public Logger(String path) {
        this.logFile = new File(path);
        logFile.createNewFile();
        // Keine Berechtigungssetzung - erbt Standard (oft 0644)
    }

    public void log(String message) {
        // Kann sensible Informationen enthalten, lesbar für andere Benutzer
        try (FileWriter writer = new FileWriter(logFile, true)) {
            writer.write(message + "\n");
        }
    }
}

// VERWUNDBAR: Weltweit ausführbares Installationsskript
public void installPlugin(Path pluginPath) throws IOException {
    // Setzt ausführbar für alle!
    Files.setPosixFilePermissions(pluginPath,
        PosixFilePermissions.fromString("rwxrwxrwx"));
}

# VERWUNDBAR: Installationsskript mit falschen Berechtigungen
#!/bin/bash

# Erstellt weltweit beschreibbares Verzeichnis
mkdir /var/myapp/data
chmod 777 /var/myapp/data

# Kopiert Anmeldedaten mit Standardberechtigungen
cp credentials.conf /etc/myapp/credentials.conf

# Erstellt setuid-Binary mit falscher Eigentümerschaft
cp myapp /usr/local/bin/myapp
chmod u+s /usr/local/bin/myapp  # Setuid aber falscher Eigentümer!

Lösungscode

# SICHER: Restriktive Berechtigungen für Konfigurationsdateien
import os
import stat

def create_config_safe():
    config_path = '/etc/myapp/config.json'

    # Restriktive umask vor Dateierstellung setzen
    old_umask = os.umask(0o077)

    try:
        with open(config_path, 'w') as f:
            f.write(json.dumps(config_data))
    finally:
        os.umask(old_umask)  # Ursprüngliche umask wiederherstellen

    # Nur-Eigentümer-Zugriff sicherstellen (0600)
    os.chmod(config_path, stat.S_IRUSR | stat.S_IWUSR)

    # Ordnungsgemäße Eigentümerschaft setzen
    os.chown(config_path, uid=app_uid, gid=app_gid)

# SICHER: Anmeldedatendatei mit restriktiven Berechtigungen
def save_credentials_safe(username, password):
    cred_file = '/app/credentials.txt'

    # Datei von Anfang an mit restriktiven Berechtigungen erstellen
    fd = os.open(cred_file,
                 os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
                 stat.S_IRUSR | stat.S_IWUSR)  # 0600

    try:
        with os.fdopen(fd, 'w') as f:
            f.write(f"{username}:{password}")
    except:
        os.close(fd)
        raise

    # Berechtigungen verifizieren
    current_mode = os.stat(cred_file).st_mode & 0o777
    if current_mode != 0o600:
        raise SecurityError(f"Anmeldedatendatei hat falsche Berechtigungen: {oct(current_mode)}")

// SICHER: Log-Datei mit ordnungsgemäßen Berechtigungen
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.PosixFilePermissions;
import java.nio.file.attribute.PosixFilePermission;
import java.util.Set;

public class SecureLogger {
    private Path logPath;

    public SecureLogger(String path) throws IOException {
        this.logPath = Path.of(path);

        // Mit restriktiven Berechtigungen erstellen
        Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rw-------");

        Files.createFile(logPath,
            PosixFilePermissions.asFileAttribute(perms));
    }

    public void log(String message) throws IOException {
        // Verifizieren, dass Berechtigungen nicht geändert wurden
        Set<PosixFilePermission> currentPerms = Files.getPosixFilePermissions(logPath);
        if (currentPerms.contains(PosixFilePermission.OTHERS_READ) ||
            currentPerms.contains(PosixFilePermission.GROUP_READ)) {
            throw new SecurityException("Log-Datei-Berechtigungen zu permissiv");
        }

        Files.writeString(logPath, message + "\n",
            StandardOpenOption.APPEND);
    }
}

// SICHER: Plugin-Installation mit ordnungsgemäßen Berechtigungen
public void installPluginSafe(Path pluginPath, String owner) throws IOException {
    // Nur Eigentümer ausführbar
    Set<PosixFilePermission> perms = EnumSet.of(
        PosixFilePermission.OWNER_READ,
        PosixFilePermission.OWNER_EXECUTE
    );

    Files.setPosixFilePermissions(pluginPath, perms);

    // Ordnungsgemäße Eigentümerschaft setzen
    UserPrincipalLookupService lookup = pluginPath.getFileSystem()
        .getUserPrincipalLookupService();
    UserPrincipal ownerPrincipal = lookup.lookupPrincipalByName(owner);
    Files.setOwner(pluginPath, ownerPrincipal);

    // Endzustand verifizieren
    PosixFileAttributes attrs = Files.readAttributes(pluginPath,
        PosixFileAttributes.class);

    if (attrs.permissions().contains(PosixFilePermission.OTHERS_EXECUTE)) {
        throw new SecurityException("Plugin sollte nicht weltweit ausführbar sein");
    }
}

#!/bin/bash
# SICHER: Installationsskript mit ordnungsgemäßen Berechtigungen

set -e  # Bei Fehler beenden
umask 077  # Restriktive Standardberechtigungen

# Verzeichnis mit ordnungsgemäßen Berechtigungen erstellen
install -d -m 0750 -o myapp -g myapp /var/myapp/data

# Anmeldedaten mit restriktiven Berechtigungen kopieren
install -m 0600 -o myapp -g myapp credentials.conf /etc/myapp/credentials.conf

# Verifizieren, dass Berechtigungen korrekt sind
PERMS=$(stat -c %a /etc/myapp/credentials.conf)
if [ "$PERMS" != "600" ]; then
    echo "FEHLER: Anmeldedatendatei hat falsche Berechtigungen: $PERMS"
    exit 1
fi

# Binary mit korrekter Eigentümerschaft installieren (kein setuid ausser unbedingt erforderlich)
install -m 0755 -o root -g root myapp /usr/local/bin/myapp

# Wenn setuid wirklich erforderlich ist, dokumentieren warum und prüfen
# install -m 4755 -o root -g root myapp /usr/local/bin/myapp

echo "Installation mit sicheren Berechtigungen abgeschlossen"

---

Ausgenutzt in der Praxis

AirVPN Eddie macOS Privilegieneskalation (AirVPN, 2025)

CVE-2025-14979 in AirVPN Eddie für macOS legt XPC-Dienste ohne ordnungsgemäße Zugriffsbeschränkungen offen und ermöglicht lokalen Angreifern die Eskalation zu Root-Privilegien ohne Authentifizierung, mit vollständiger Auswirkung auf Vertraulichkeit, Integrität und Verfügbarkeit.

• https://radar.offseq.com/

IBM i Privilegieneskalation (IBM, 2025)

CVE-2025-2947 in IBM i 7.6 ermöglicht entfernten privilegierten Benutzern die Eskalation zu Root-Zugriff durch falsches Profil-Swapping während der OS-Befehlsausführung.

• https://www.cybersecurity-help.cz/vdb/SB2025041810

Kaspersky Security Center (Kaspersky, 2025)

Kaspersky Security Center für Windows (CVSS 7.1) hatte falsches Berechtigungsmanagement bei gemeinsamen Konfigurationsressourcen, was Kompromittierung der Datenintegrität ermöglichte.

• https://www.kaspersky.com/about/press-releases

---

Tools zum Testen/Ausnutzen

• Lynis - Dateiberechtigungen auf Linux-Systemen prüfen.

• AccessChk - Windows-Berechtigungsanalyse.

• Linux Exploit Suggester - Berechtigungsbasierte Exploits identifizieren.

---

CVE-Beispiele

• CVE-2025-14979 - AirVPN Eddie XPC-Privilegieneskalation.

• CVE-2025-2947 - IBM i Root-Privilegieneskalation.

• CVE-2024-31202 - ThermoscanIP lokale Privilegieneskalation.

---

Referenzen

1. MITRE. "CWE-732: Incorrect Permission Assignment for Critical Resource." https://cwe.mitre.org/data/definitions/732.html

2. OWASP. "Insecure Default Configuration." https://owasp.org/www-project-web-security-testing-guide/