Privilegienverkettung

Beschreibung

Privilegienverkettung ist eine Schwachstelle, die auftritt, wenn zwei unterschiedliche Privilegien, Rollen, Fähigkeiten oder Rechte so kombiniert werden können, dass eine Entität unsichere Aktionen ausführen kann, die nicht erlaubt wären, wenn jedes Privileg einzeln ausgeübt würde. Die Schwachstelle entsteht nicht aus einem einzelnen übermäßigen Privileg, sondern aus der Interaktion zwischen mehreren Privilegien, wenn sie von derselben Entität gehalten werden. Dies kann auftreten, wenn Privilegiensysteme ohne Berücksichtigung des kumulativen Effekts der Kombination von Berechtigungen entworfen werden, wenn rollenbasierte Zugriffskontrolle gefährliche Rollenkombinationen erlaubt, oder wenn Fähigkeitsvererbung unbeabsichtigte Privilegieneskalationspfade erzeugt.

Risiko

Privilegienverkettung erzeugt erhebliche Sicherheitsrisiken, da jedes einzelne Privileg bei isolierter Analyse sicher erscheinen kann, aber ihre Kombination gefährliche Fähigkeiten erzeugt. Benutzer oder Prozesse mit mehreren legitimen Rollen können unbeabsichtigt Zugang zu Funktionalität oder Daten erhalten, die höhere Autorisierung erfordern sollten. Angreifer, die mehrere Privilegien erlangen oder manipulieren können, können diese für Privilegieneskalation verketten. Das Risiko ist besonders akut in komplexen Systemen mit zahlreichen Rollen und Berechtigungen, wo die Interaktionsmatrix schwer vollständig zu analysieren ist. Administrative Versäumnisse bei der Rollenzuweisung können gefährliche Kombinationen erzeugen, die bis zur Ausnutzung unentdeckt bleiben.

Lösung

Implementieren Sie Privilegienanalyse, die den kumulativen Effekt mehrerer Privilegien berücksichtigt, wenn sie derselben Entität zugewiesen werden. Erstellen Sie eine Privilegieninkompatibilitätsmatrix, die gefährliche Kombinationen identifiziert und deren gleichzeitige Zuweisung verhindert. Wenden Sie das Prinzip der Funktionstrennung an, um sicherzustellen, dass kritische Aktionen mehrere unabhängige Akteure erfordern, anstatt mehrere Privilegien, die von einem Akteur gehalten werden. Implementieren Sie Laufzeitprüfungen, die gefährliche Privilegienkombinationen erkennen und verhindern. Verwenden Sie Rollenhierarchie-Analysetools, um potenzielle Verkettungsschwachstellen zu identifizieren. Entwerfen Sie Privilegiensysteme mit minimaler Überlappung zwischen Fähigkeiten. Führen Sie regelmäßige Audits der Privilegienzuweisungen durch, um gefährliche Kombinationen zu erkennen. Dokumentieren Sie erwartete Privilegienkombinationen und implementieren Sie technische Kontrollen zur Durchsetzung dieser Einschränkungen.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Zugriffskontrolle Angreifer oder legitime Benutzer, die mehrere Privilegien halten, können diese kombinieren, um Aktionen über den beabsichtigten Autorisierungsbereich hinaus auszuführen. Dies kann den Zugriff auf eingeschränkte Daten, die Ausführung administrativer Operationen oder die Umgehung von Sicherheitskontrollen durch den kumulativen Effekt einzeln sicherer Privilegien umfassen.

Beispielcode

Anfälliger Code (Python)

Die folgenden Beispiele demonstrieren Privilegienverkettungs-Schwachstellen:

# Anfällig: Privilegien, die sich unsicher kombinieren
class VulnerablePrivilegeSystem:

    def __init__(self):
        self.privileges = {
            'view_audit_log': {'view_logs', 'read_user_ids'},
            'manage_user_profiles': {'read_user_profiles', 'write_user_profiles'},
            'run_reports': {'execute_queries', 'export_data'},
            'debug_system': {'read_memory', 'attach_debugger'}
        }

    def check_permission(self, user, action):
        # Jedes Privileg unabhängig prüfen
        for privilege in user.privileges:
            if action in self.privileges.get(privilege, set()):
                return True
        return False

    def perform_action(self, user, action, target):
        if self.check_permission(user, action):
            # Anfällig: Keine Prüfung auf gefährliche Privilegienkombinationen
            # Benutzer mit 'view_audit_log' + 'manage_user_profiles' kann:
            # 1. Benutzer-IDs aus Audit-Log lesen
            # 2. Diese Benutzerprofile modifizieren
            # Kombinierter Effekt: Jeden Benutzer verfolgen und modifizieren
            return self.execute_action(action, target)
        return False


class VulnerableDocumentSystem:

    def __init__(self):
        # Einzelne Privilegien scheinen sicher
        self.role_permissions = {
            'document_viewer': ['read_documents', 'list_documents'],
            'template_manager': ['read_templates', 'modify_templates'],
            'workflow_admin': ['modify_workflow', 'assign_workflow']
        }

    def can_access(self, user, action):
        for role in user.roles:
            if action in self.role_permissions.get(role, []):
                return True
        return False

    def process_document(self, user, document_id, action):
        # Anfällige Privilegienkette:
        # 1. template_manager kann Vorlagen modifizieren
        # 2. workflow_admin kann Vorlagen Workflows zuweisen
        # 3. Kombination beider: Bösartige Vorlage erstellen, kritischem Workflow zuweisen
        #    -> Betrifft alle Dokumente, die durch diesen Workflow verarbeitet werden

        if self.can_access(user, action):
            # Keine Erkennung gefährlicher Rollenkombinationen
            self.execute_action(document_id, action)

// Anfällig: Datenbank-Privilegienverkettung
public class VulnerableDatabasePrivileges {

    public void grantPrivileges(User user, List<String> requestedPrivileges) {
        for (String privilege : requestedPrivileges) {
            // Jedes Privileg unabhängig geprüft
            if (isValidPrivilege(privilege)) {
                user.addPrivilege(privilege);
            }
        }

        // Anfällig: Keine Prüfung auf gefährliche Kombinationen
        // Benutzer mit SELECT + TRIGGER Privilegien kann:
        // 1. SELECT aus sensiblen Tabellen (erlaubt)
        // 2. Trigger erstellen, der bei ihrem SELECT ausgeführt wird
        // 3. Trigger läuft mit Definer-Privilegien, nicht Invoker
        // Kombinierter Effekt: Privilegieneskalation durch Trigger-Ausnutzung
    }
}

Korrigierter Code (Python)

# Korrigiert: Gefährliche Privilegienkombinationen erkennen und verhindern
class SecurePrivilegeSystem:

    def __init__(self):
        self.privileges = {
            'view_audit_log': {'view_logs', 'read_user_ids'},
            'manage_user_profiles': {'read_user_profiles', 'write_user_profiles'},
            'run_reports': {'execute_queries', 'export_data'},
            'debug_system': {'read_memory', 'attach_debugger'}
        }

        # Inkompatible Privilegienkombinationen definieren
        self.incompatible_privileges = [
            # Kann nicht sowohl Audit-Einsicht als auch Profilverwaltung haben
            {'view_audit_log', 'manage_user_profiles'},
            # Kann nicht sowohl Debug als auch Datenexport haben
            {'debug_system', 'run_reports'},
            # Kann nicht sowohl Speicherzugriff als auch Netzwerkzugriff haben
            {'debug_system', 'network_admin'},
        ]

        # Aktionen, die Funktionstrennung erfordern
        self.dual_control_actions = {
            'delete_audit_log': ['audit_admin', 'security_officer'],
            'modify_security_policy': ['security_admin', 'compliance_officer'],
            'emergency_access': ['admin', 'manager_approval']
        }

    def validate_privilege_assignment(self, user, new_privilege):
        """Prüfen ob Hinzufügen des Privilegs gefährliche Kombination erzeugt"""
        proposed_privileges = user.privileges | {new_privilege}

        for incompatible_set in self.incompatible_privileges:
            if incompatible_set.issubset(proposed_privileges):
                raise PrivilegeConflictError(
                    f"Kann {incompatible_set} nicht kombinieren - Sicherheitsverletzung"
                )

        return True

    def check_permission(self, user, action, require_dual_control=True):
        # Auf Dual-Control-Anforderungen prüfen
        if action in self.dual_control_actions and require_dual_control:
            required_roles = self.dual_control_actions[action]
            if not self._has_dual_authorization(user, required_roles):
                raise DualControlRequired(
                    f"Aktion {action} erfordert Genehmigung von: {required_roles}"
                )

        # Standard-Berechtigungsprüfung
        for privilege in user.privileges:
            if action in self.privileges.get(privilege, set()):
                return True
        return False

    def _has_dual_authorization(self, user, required_roles):
        """Sicherstellen, dass Aktion von mehreren unabhängigen Parteien autorisiert ist"""
        # Benutzer kann sich nicht selbst für Dual-Control-Aktionen autorisieren
        authorizations = self.pending_authorizations.get(user.id, {})

        for role in required_roles:
            if role in user.roles:
                # Benutzer hat die Rolle, braucht Autorisierung von jemand anderem
                if not authorizations.get(role):
                    return False

        return True

    def assign_privilege(self, assigner, target_user, privilege):
        """Privileg mit Verkettungserkennung zuweisen"""

        # Validieren, dass Zuweisung keine gefährlichen Ketten erzeugt
        self.validate_privilege_assignment(target_user, privilege)

        # Für Audit protokollieren
        self.audit_log.record(
            action='privilege_assigned',
            assigner=assigner.id,
            target=target_user.id,
            privilege=privilege,
            resulting_privileges=list(target_user.privileges | {privilege})
        )

        target_user.privileges.add(privilege)


class SecureDocumentSystem:

    # Rolleninkompatibilitätsmatrix
    INCOMPATIBLE_ROLES = {
        frozenset(['template_manager', 'workflow_admin']),
        frozenset(['document_approver', 'document_creator']),
        frozenset(['security_auditor', 'system_admin']),
    }

    def assign_role(self, user, role):
        proposed_roles = set(user.roles) | {role}

        for incompatible in self.INCOMPATIBLE_ROLES:
            if incompatible.issubset(proposed_roles):
                raise RoleConflictError(
                    f"Kann {role} nicht zuweisen: Konflikt mit existierenden Rollen. "
                    f"Inkompatible Kombination: {incompatible}"
                )

        user.roles.append(role)
        self.audit_log.record('role_assigned', user.id, role)

    def analyze_privilege_chains(self, user):
        """Potenzielle Privilegienverkettungsrisiken erkennen"""
        warnings = []

        # Transitive Fähigkeiten analysieren
        all_capabilities = set()
        for role in user.roles:
            all_capabilities.update(self.get_role_capabilities(role))

        # Auf gefährliche Fähigkeitskombinationen prüfen
        dangerous_combos = [
            ({'read_sensitive_data', 'export_data'}, 'Kann sensible Daten exfiltrieren'),
            ({'modify_templates', 'auto_approve'}, 'Kann eigene Änderungen genehmigen'),
            ({'create_users', 'assign_admin'}, 'Kann Admin-Konten erstellen'),
        ]

        for combo, risk in dangerous_combos:
            if combo.issubset(all_capabilities):
                warnings.append(f"Warnung: {risk}")

        return warnings

Die Korrektur implementiert Privilegieninkompatibilitätsprüfung, Dual-Control für sensible Aktionen, Rollenkonflikt-Erkennung und Privilegienkettenanalyse, um gefährliche Kombinationen zu verhindern.

---

Ausgenutzt in der Praxis

Datenbank-Trigger-Privilegieneskalation (Mehrere DBMS, Fortlaufend)

Kombinationen scheinbar sicherer Datenbankprivilegien wie SELECT und CREATE TRIGGER wurden für Privilegieneskalation ausgenutzt. Angreifer mit begrenztem Query-Zugang erstellen Trigger, die mit erhöhten Definer-Privilegien ausgeführt werden, was effektiv ihren Zugang über das hinaus eskaliert, was jedes Privileg allein erlauben würde.

• https://www.exploit-db.com/

AWS IAM-Rollenverkettung (Cloud-Umgebungen, Fortlaufend)

AWS IAM-Rollenübernahmeketten wurden ausgenutzt, wenn Benutzer mit begrenzten Rollen Zwischenrollen übernehmen können, die privilegiertere Rollen übernehmen können. Die Kombination von iam:PassRole und anderen Berechtigungen erzeugt Eskalationspfade, die aus individueller Privilegienanalyse nicht offensichtlich sind.

• https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/

Active Directory ACL-Verkettung (Unternehmensumgebungen, Fortlaufend)

Active Directory-Umgebungen wurden durch ACL-Privilegienverkettung kompromittiert, bei der Benutzer mit Schreibzugriff auf bestimmte Objekte und Mitgliedschaft in spezifischen Gruppen Sicherheitsdeskriptoren modifizieren können, um Domain-Admin-Zugang durch eine Kette von Berechtigungsmanipulationen zu erlangen.

• https://adsecurity.org/

---

Tools zum Testen/Ausnutzen

• BloodHound — Identifiziert Active Directory-Privilegieneskalationspfade durch Berechtigungsverkettung.

• PMapper — AWS IAM-Analysetool, das Privilegienverkettung und Eskalationspfade identifiziert.

• Prowler — Cloud-Sicherheitstool, das gefährliche IAM-Privilegienkombinationen identifiziert.

---

CVE-Beispiele

• CVE-2005-1736 — Kombination von Debug- und Dateizugriffsprivilegien ermöglichte Privilegieneskalation.

• CVE-2002-1772 — Mehrfache Privilegienkombination ermöglichte unbefugten Zugriff.

• CVE-2005-1973 — Privilegienverkettung in Webanwendung führte zu Administrator-Zugang.

• CVE-2003-0640 — Kombinierte Privilegien ermöglichten Umgehung beabsichtigter Zugriffsbeschränkungen.

---

Referenzen

1. MITRE Corporation. "CWE-268: Privilege Chaining." Common Weakness Enumeration. https://cwe.mitre.org/data/definitions/268.html

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

3. NIST. "Role-Based Access Control." NIST RBAC. https://csrc.nist.gov/projects/role-based-access-control