Falsche Privilegienzuweisung
Beschreibung
Falsche Privilegienzuweisung ist eine Schwachstelle, die auftritt, wenn ein Produkt einem bestimmten Akteur ein Privileg, eine Rolle, eine Fähigkeit oder eine Berechtigung falsch zuweist und damit einen unbeabsichtigten Kontrollbereich für diese Entität erzeugt. Diese Schwäche kann sich auf mehrere Arten manifestieren: Gewährung erhöhter Privilegien während der Benutzererstellung, Zuweisung von Benutzern zu falschen Gruppen, Anwendung falscher Berechtigungssätze auf Ressourcen oder Versäumnis, Privilegienvererbung ordnungsgemäß einzuschränken. Das Ergebnis ist, dass Akteure Zugang zu Funktionalität oder Daten erhalten, auf die sie nicht zugreifen sollten, möglicherweise einschließlich administrativer Fähigkeiten, sensibler Informationen oder Kontrolle über die Ressourcen anderer Benutzer.
Risiko
Falsche Privilegienzuweisung erzeugt erhebliche Sicherheitsrisiken, indem sie unbefugten Zugang zu geschützten Ressourcen und Funktionalität bietet. Benutzer mit falsch erhöhten Privilegien können auf sensible Daten zugreifen, Systemkonfigurationen ändern, Konten erstellen oder löschen und Aktionen ausführen, die Administratoren vorbehalten sind. In Multi-Tenant-Umgebungen können Privilegienzuweisungsfehler Cross-Tenant-Zugang ermöglichen. Das Risiko wird verstärkt, wenn Privilegienzuweisung während automatisierter Prozesse wie Benutzerbereitstellung, rollenbasierter Zugriffskontroll-Implementierung oder Berechtigungssynchronisation erfolgt, wo Fehler viele Benutzer gleichzeitig betreffen können. Angreifer, die Privilegienzuweisungsfehler identifizieren, können sie für Privilegieneskalation, Lateral Movement und dauerhaften Zugang ausnutzen.
Lösung
Implementieren Sie das Prinzip der geringsten Privilegien und stellen Sie sicher, dass Benutzer nur die minimal notwendigen Berechtigungen für ihre Aufgaben erhalten. Verwenden Sie rollenbasierte Zugriffskontrolle (RBAC) mit sorgfältig definierten Rollen, die auf spezifische Jobfunktionen abgebildet werden. Implementieren Sie automatisierte Privilegienaudits zur Erkennung von Zuweisungsfehlern. Schaffen Sie Trennung zwischen Benutzerbereitstellungs- und Privilegienzuweisungsprozessen mit entsprechenden Genehmigungsworkflows. Testen Sie Privilegienzuweisungslogik gründlich, einschließlich Grenzfälle und Randbedingungen. Implementieren Sie Logging und Alerting für Privilegienänderungen. Verwenden Sie Gruppenmitgliedschafts- und Rollenzuweisungs-Reviews, um regelmäßig zu validieren, dass Privilegien angemessen bleiben. Vermeiden Sie direkte Privilegienzuweisung wo möglich und bevorzugen Sie rollenbasierte Mechanismen, die einfacher zu auditieren sind.
Häufige Auswirkungen
| Auswirkung | Details |
|---|---|
| Zugriffskontrolle | Bereich: Zugriffskontrolle Benutzer können durch falsch zugewiesene Privilegien auf eingeschränkte Funktionalität und sensible Informationen zugreifen. Dies kann administrative Fähigkeiten, Konten anderer Benutzer und geschützte Ressourcen über den beabsichtigten Zugriffsbereich hinaus umfassen. |
Beispielcode
Anfälliger Code (Python/Django)
Der folgende Code demonstriert falsche Privilegienzuweisungsmuster:
from django.contrib.auth.models import User, Group
from django.db import models
class VulnerableUserService:
def create_user(self, username, email, role_name):
user = User.objects.create_user(username=username, email=email)
# Anfällig: Falsche Gruppenzuweisungslogik
if role_name == "admin":
# Korrekt: Admin-Gruppe
admin_group = Group.objects.get(name="Administrators")
user.groups.add(admin_group)
elif role_name == "manager":
# BUG: Weist Managern versehentlich Admin-Privilegien zu!
admin_group = Group.objects.get(name="Administrators")
user.groups.add(admin_group) # Sollte "Managers"-Gruppe sein
else:
# Standard-Benutzer
user_group = Group.objects.get(name="Users")
user.groups.add(user_group)
return user
def copy_user_permissions(self, source_user, target_user):
# Anfällig: Kopiert blind alle Berechtigungen einschließlich sensibler
target_user.groups.set(source_user.groups.all())
target_user.user_permissions.set(source_user.user_permissions.all())
target_user.save()
def promote_user(self, user, new_role):
# Anfällig: Keine Validierung, dass Beförderung autorisiert ist
# Jeder Benutzer kann dies aufrufen und sich selbst befördern
if new_role == "admin":
admin_group = Group.objects.get(name="Administrators")
user.groups.add(admin_group)
user.is_staff = True
user.is_superuser = True # Gewährt alle Berechtigungen!
user.save()
// Anfälliges Java-Beispiel
public class VulnerableRoleService {
public void assignRole(User user, String roleName) {
// Anfällig: Verwendet benutzergelieferte Rolle ohne Validierung
Role role = roleRepository.findByName(roleName);
if (role != null) {
// Keine Prüfung, ob aktueller Benutzer diese Rolle zuweisen darf
// Keine Prüfung, ob Zielbenutzer diese Rolle erhalten sollte
user.getRoles().add(role);
userRepository.save(user);
}
}
public void createServiceAccount(String name, String purpose) {
User serviceAccount = new User();
serviceAccount.setUsername(name);
serviceAccount.setServiceAccount(true);
// Anfällig: Service-Konten erhalten übermäßige Standard-Privilegien
Role serviceRole = roleRepository.findByName("SERVICE_ADMIN");
serviceAccount.getRoles().add(serviceRole); // Zu viel Zugang!
userRepository.save(serviceAccount);
}
}
Korrigierter Code (Python/Django)
from django.contrib.auth.models import User, Group, Permission
from django.core.exceptions import PermissionDenied
import logging
logger = logging.getLogger(__name__)
class SecureUserService:
# Gültige Rollenzuordnungen definieren
ROLE_MAPPINGS = {
"admin": "Administrators",
"manager": "Managers",
"analyst": "Analysts",
"user": "Users"
}
# Rollen, die erhöhte Autorisierung zur Zuweisung erfordern
PRIVILEGED_ROLES = {"admin", "manager"}
def create_user(self, username, email, role_name, created_by):
# Rollenname validieren
if role_name not in self.ROLE_MAPPINGS:
raise ValueError(f"Ungültige Rolle: {role_name}")
# Prüfen, ob Ersteller autorisiert ist, diese Rolle zuzuweisen
if role_name in self.PRIVILEGED_ROLES:
if not created_by.has_perm('auth.assign_privileged_roles'):
logger.warning(
f"Unbefugter Privilegienzuweisungsversuch: "
f"{created_by.username} versuchte {role_name} zuzuweisen"
)
raise PermissionDenied("Nicht autorisiert, diese Rolle zuzuweisen")
user = User.objects.create_user(username=username, email=email)
# Validierte Rollenzuordnung verwenden
group_name = self.ROLE_MAPPINGS[role_name]
group = Group.objects.get(name=group_name)
user.groups.add(group)
# Audit-Log
logger.info(
f"Benutzer {username} mit Rolle {role_name} erstellt von {created_by.username}"
)
return user
def assign_role(self, user, role_name, assigned_by):
"""Sichere Rollenzuweisung mit Autorisierungsprüfungen"""
# Rolle validieren
if role_name not in self.ROLE_MAPPINGS:
raise ValueError(f"Ungültige Rolle: {role_name}")
# Autorisierung für privilegierte Rollenzuweisung prüfen
if role_name in self.PRIVILEGED_ROLES:
if not self._can_assign_privileged_role(assigned_by, user, role_name):
raise PermissionDenied("Nicht autorisiert für diese Rollenzuweisung")
group_name = self.ROLE_MAPPINGS[role_name]
group = Group.objects.get(name=group_name)
# Existierende Rollen löschen und neue zuweisen
user.groups.clear()
user.groups.add(group)
# Staff/Superuser-Flags entsprechend aktualisieren
user.is_staff = role_name in self.PRIVILEGED_ROLES
user.is_superuser = (role_name == "admin")
user.save()
logger.info(
f"Rolle {role_name} an {user.username} zugewiesen von {assigned_by.username}"
)
def _can_assign_privileged_role(self, assigner, target, role):
"""Prüfen, ob Zuweiser Rolle an Ziel zuweisen kann"""
# Kann nicht an sich selbst zuweisen
if assigner.id == target.id:
return False
# Muss Rollenzuweisungsberechtigung haben
if not assigner.has_perm('auth.assign_privileged_roles'):
return False
# Admin-Rolle erfordert Superuser
if role == "admin" and not assigner.is_superuser:
return False
return True
def copy_permissions_safely(self, source_user, target_user, copied_by):
"""Berechtigungen mit Filterung kopieren"""
# Privilegierte Berechtigungen nicht kopieren
EXCLUDED_PERMISSIONS = [
'auth.assign_privileged_roles',
'auth.delete_user',
'admin.full_access'
]
# Gruppen kopieren (Admin-Gruppen ausschließen)
safe_groups = source_user.groups.exclude(name="Administrators")
target_user.groups.set(safe_groups)
# Individuelle Berechtigungen kopieren (gefährliche ausschließen)
safe_permissions = source_user.user_permissions.exclude(
codename__in=[p.split('.')[1] for p in EXCLUDED_PERMISSIONS]
)
target_user.user_permissions.set(safe_permissions)
target_user.save()
logger.info(
f"Berechtigungen von {source_user.username} nach "
f"{target_user.username} kopiert von {copied_by.username}"
)
Die Korrektur implementiert ordnungsgemäße Rollenvalidierung, Autorisierungsprüfungen für privilegierte Rollenzuweisung, verhindert Selbstbeförderung, schließt gefährliche Berechtigungen von Kopieroperationen aus und loggt alle Privilegienänderungen.
Ausgenutzt in der Praxis
Unix Wheel-Gruppen-Schwachstelle (Unix-Systeme, 1999)
CVE-1999-1193 dokumentierte einen klassischen Privilegienzuweisungsfehler, bei dem ein nicht vertrauenswürdiger Benutzer fälschlicherweise in die Unix-"wheel"-Gruppe aufgenommen wurde, die traditionell sudo/su-Zugang gewährt. Dies ermöglichte dem Benutzer die Eskalation zu Root-Privilegien und demonstrierte, wie falsche Gruppenmitgliedschaft zu vollständiger Systemkompromittierung führen kann.
AWS IAM Privilegieneskalation (Mehrere Organisationen, Fortlaufend)
Fehlkonfigurierte AWS IAM-Richtlinien haben zu zahlreichen Privilegieneskalationsvorfällen geführt, bei denen Benutzern versehentlich Berechtigungen gewährt wurden, ihre eigenen IAM-Richtlinien zu ändern oder Rollen mit erhöhtem Zugang anzunehmen. Angreifer nutzen diese Zuweisungsfehler, um von begrenztem Zugang zu administrativer Kontrolle über AWS-Konten zu eskalieren.
Active Directory Gruppen-Verschachtelungsprobleme (Enterprise-Umgebungen, Fortlaufend)
Komplexe Active-Directory-Gruppen-Verschachtelung hat dazu geführt, dass Benutzer administrative Privilegien durch transitive Gruppenmitgliedschaft erbten. Benutzer, die zu scheinbar harmlosen Gruppen hinzugefügt wurden, erhielten versehentlich Domain-Admin-Zugang durch verschachtelte Gruppenbeziehungen, was unbefugten Zugriff auf sensible Systeme ermöglichte.
Tools zum Testen/Ausnutzen
-
BloodHound — Active-Directory-Privilegienpfad-Analysetool, das Privilegienzuweisungsprobleme und Eskalationspfade identifiziert.
-
Prowler — AWS-Sicherheitsbewertungstool, das IAM-Privilegienzuweisungs-Fehlkonfigurationen identifiziert.
-
PrincipalMapper — AWS IAM-Analysetool zur Identifizierung falscher Privilegienzuweisungen und Eskalationspfade.
CVE-Beispiele
-
CVE-1999-1193 — Nicht vertrauenswürdiger Benutzer fälschlicherweise in Unix-Wheel-Gruppe aufgenommen, ermöglichte Privilegieneskalation.
-
CVE-2005-2741 — Produkt erlaubte Benutzern, sich selbst bestimmte Rechte für Privilegieneskalation zu gewähren.
-
CVE-2005-2496 — Anwendung verwendete falsche Gruppen-ID, was Ausführung mit falschen Privilegien verursachte.
-
CVE-2004-0274 — Falsche Statuszuweisung resultierte in unbeabsichtigter Privilegienerhöhung.
Referenzen
-
MITRE Corporation. "CWE-266: Incorrect Privilege Assignment." Common Weakness Enumeration. https://cwe.mitre.org/data/definitions/266.html
-
OWASP Foundation. "Broken Access Control." OWASP Top 10. https://owasp.org/Top10/A01_2021-Broken_Access_Control/
-
NIST. "Guide to Attribute Based Access Control (ABAC) Definition and Considerations." SP 800-162. https://csrc.nist.gov/publications/detail/sp/800-162/final