Externe Beeinflussung der Sphärendefinition

Beschreibung

Externe Beeinflussung der Sphärendefinition tritt auf, wenn ein externer Akteur die Grenzen oder Definitionen von Schutzdomänen, Vertrauenszonen oder Sicherheitssphären modifizieren kann. Dies umfasst das Erlauben, dass Benutzer kontrollieren, welche Ressourcen zu welchem Sicherheitskontext gehören, Zugriffskontrollgrenzen modifizieren, Vertrauensbeziehungen neu definieren oder beeinflussen, wie Privilegientrennung angewendet wird. Angreifer können dies ausnutzen, um ihren Zugriff zu erweitern oder nicht autorisierte Ressourcen in ihre Kontrollsphäre einzubeziehen.

Risiko

Angreifer erweitern ihre Sicherheitssphäre, um geschützte Ressourcen einzuschließen. Vertrauensgrenzen können neu definiert werden, um Zugriffskontrollen zu umgehen. Sicherheitsdomänen können zusammengeführt werden, um Isolation zu eliminieren. Privilegiengrenzen können modifiziert werden, um erhöhten Zugriff zu erlangen. Multi-Tenant-Isolation kann gebrochen werden. Schutzmechanismen können durch Änderung ihres Geltungsbereichs umgangen werden.

Lösung

Erzwingen Sie Sphärendefinitionen serverseitig. Erlauben Sie keine externe Eingabe zur Modifikation von Sicherheitsgrenzen. Validieren Sie alle Vertrauensbeziehungsänderungen. Implementieren Sie unveränderliche Sicherheitsdomänendefinitionen. Verwenden Sie kryptografische Bindung für Sphärenmitgliedschaft. Auditieren Sie alle Grenzmodifikationen. Wenden Sie das Prinzip der geringsten Privilegien auf die Sphärenverwaltung an.

Häufige Auswirkungen

Auswirkung	Details
Autorisierung	Bereich: Zugriffskontrollumgehung Erweiterung der Sphäre schließt geschützte Ressourcen ein.
Vertraulichkeit	Bereich: Datenoffenlegung Modifikation von Grenzen legt geschützte Daten offen.
Integrität	Bereich: Privilegieneskalation Änderung von Vertrauensbeziehungen gewährt erhöhten Zugriff.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: Externe Beeinflussung von Sicherheitssphären
@RestController
public class VerwundbarerSecurityController {

    // VERWUNDBAR: Benutzer kontrolliert seine eigenen Rollen
    @PostMapping("/api/user/roles")
    public void updateRoles(@RequestBody RoleUpdateRequest request) {
        User user = getCurrentUser();
        // VERWUNDBAR: Benutzer definiert seine eigene Sicherheitssphäre
        user.setRoles(request.getRoles());  // Kann 'admin'-Rolle hinzufügen!
        userRepository.save(user);
    }

    // VERWUNDBAR: Benutzer kontrolliert Ressourcenzugriffsdefinitionen
    @PostMapping("/api/access-rules")
    public void defineAccessRules(@RequestBody AccessRuleRequest request) {
        // VERWUNDBAR: Benutzer definiert, worauf er zugreifen kann
        AccessRule rule = new AccessRule();
        rule.setUserId(getCurrentUser().getId());
        rule.setResourcePattern(request.getPattern());  // Kann "*" setzen
        rule.setPermissions(request.getPermissions());  // Kann "ALL" setzen
        accessRuleRepository.save(rule);
    }

    // VERWUNDBAR: Benutzer kontrolliert Tenant-Grenzen
    @PostMapping("/api/tenant/switch")
    public void switchTenant(@RequestParam Long tenantId) {
        User user = getCurrentUser();
        // VERWUNDBAR: Benutzer kann zu beliebigem Tenant wechseln
        user.setCurrentTenant(tenantId);  // Cross-Tenant-Zugriff
        sessionService.updateTenant(user, tenantId);
    }
}

# VERWUNDBAR: Python externe Sphärenbeeinflussung
from flask import Flask, request, session

app = Flask(__name__)

# VERWUNDBAR: Benutzer kontrolliert seine Berechtigungen
@app.route('/api/user/permissions', methods=['POST'])
def update_permissions():
    user_id = session['user_id']
    permissions = request.json.get('permissions', [])

    # VERWUNDBAR: Benutzer definiert seine eigene Berechtigungssphäre
    db.execute(
        "UPDATE users SET permissions = %s WHERE id = %s",
        (json.dumps(permissions), user_id)
    )
    return {'status': 'ok'}

# VERWUNDBAR: Benutzer kontrolliert API-Zugriffsbereich
@app.route('/api/token', methods=['POST'])
def create_token():
    requested_scopes = request.json.get('scopes', [])

    # VERWUNDBAR: Benutzer wählt seine eigenen Scopes
    token = create_jwt_token(
        user_id=session['user_id'],
        scopes=requested_scopes  # Kann 'admin:*' anfordern
    )
    return {'token': token}

Sichere Lösung

// SICHER: Serverkontrollierte Sicherheitssphären
@RestController
public class SichererSecurityController {

    @Autowired
    private RoleService roleService;

    @Autowired
    private AuditService auditService;

    // SICHER: Rollen werden nur von Admins zugewiesen
    @PostMapping("/api/admin/user/{userId}/roles")
    @PreAuthorize("hasRole('USER_ADMIN')")
    public void updateRoles(
            @PathVariable Long userId,
            @RequestBody RoleUpdateRequest request) {

        // SICHER: Validiere, dass angeforderte Rollen zuweisbar sind
        Set<String> requestedRoles = request.getRoles();
        Set<String> assignableRoles = roleService.getAssignableRoles(getCurrentUser());

        if (!assignableRoles.containsAll(requestedRoles)) {
            throw new ForbiddenException("Kann diese Rollen nicht zuweisen");
        }

        User targetUser = userRepository.findById(userId)
            .orElseThrow(() -> new NotFoundException("Benutzer nicht gefunden"));

        auditService.log("ROLE_CHANGE", getCurrentUser(), targetUser, requestedRoles);

        targetUser.setRoles(requestedRoles);
        userRepository.save(targetUser);
    }

    // SICHER: Tenant-Wechsel basierend auf autorisierten Tenants des Benutzers
    @PostMapping("/api/tenant/switch")
    public void switchTenant(@RequestParam Long tenantId) {
        User user = getCurrentUser();

        // SICHER: Verifiziere, dass Benutzer für diesen Tenant autorisiert ist
        if (!user.getAuthorizedTenants().contains(tenantId)) {
            throw new ForbiddenException("Nicht für Tenant autorisiert");
        }

        auditService.log("TENANT_SWITCH", user, tenantId);
        sessionService.updateTenant(user, tenantId);
    }
}

# SICHER: Python mit serverkontrollierten Sphären
from flask import Flask, request, session
from functools import wraps

app = Flask(__name__)

def admin_required(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if not current_user.is_admin:
            return {'error': 'Verboten'}, 403
        return f(*args, **kwargs)
    return decorated

# SICHER: Berechtigungen werden nur von Admins zugewiesen
@app.route('/api/admin/user/<user_id>/permissions', methods=['POST'])
@admin_required
def update_user_permissions(user_id):
    permissions = request.json.get('permissions', [])

    # SICHER: Validiere, dass Berechtigungen gültig und zuweisbar sind
    valid_permissions = get_valid_permissions()
    if not all(p in valid_permissions for p in permissions):
        return {'error': 'Ungültige Berechtigungen'}, 400

    # SICHER: Admin kann nur Berechtigungen zuweisen, die er hat
    if not can_assign_permissions(current_user, permissions):
        return {'error': 'Kann diese Berechtigungen nicht zuweisen'}, 403

    audit_log('PERMISSION_CHANGE', current_user, user_id, permissions)

    db.execute(
        "UPDATE users SET permissions = %s WHERE id = %s",
        (json.dumps(permissions), user_id)
    )
    return {'status': 'ok'}

# SICHER: Token-Scopes auf Benutzerberechtigungen beschränkt
@app.route('/api/token', methods=['POST'])
def create_token():
    requested_scopes = request.json.get('scopes', [])

    # SICHER: Filter auf nur erlaubte Scopes
    user_allowed_scopes = get_user_allowed_scopes(current_user)
    granted_scopes = [s for s in requested_scopes if s in user_allowed_scopes]

    token = create_jwt_token(
        user_id=session['user_id'],
        scopes=granted_scopes  # Nur servervalidierte Scopes
    )

    return {'token': token, 'scopes': granted_scopes}

---

Ausgenutzt in der Praxis

OAuth Scope-Eskalation (verschiedene Anbieter, 2019-2021)

Mehrere OAuth-Implementierungen erlaubten es Angreifern, Scopes in Token-Anfragen zu manipulieren und Berechtigungen zu erhalten, die über das hinausgingen, was ihnen gewährt wurde. Dies führte zu unbefugtem Zugriff auf Benutzerdaten bei großen Plattformen.

• https://portswigger.net/research/hidden-oauth-attack-vectors

Multi-Tenant-Datenleck (Salesforce, 2019)

Eine Fehlkonfiguration ermöglichte es Benutzern, Tenant-Grenzen zu überschreiten und auf Daten anderer Organisationen zuzugreifen. Dies betraf mehrere Unternehmen, deren Daten unbeabsichtigt offengelegt wurden.

• https://www.zdnet.com/article/salesforce-pardot-lightning-data-breach/

GitHub OAuth-Schwachstelle (GitHub, 2022)

Eine Schwachstelle in GitHubs OAuth-Implementierung ermöglichte es Angreifern, OAuth-Token mit erweiterten Scopes zu generieren und auf private Repositories zuzugreifen.

• https://github.blog/2022-04-15-security-alert-stolen-oauth-user-tokens/

---

Tools zum Testen und Ausnutzen

• Burp Suite — Web-Sicherheitsscanner mit OAuth- und Autorisierungstestfunktionen.

• OWASP ZAP — Open-Source-Sicherheitsscanner für Autorisierungstests.

• Postman — API-Testplattform zur Manipulation von Autorisierungsparametern.

---

CVE-Beispiele

• CVE-2021-39115 — Atlassian Jira Privilegieneskalation durch Berechtigungsmanipulation.

• CVE-2020-8945 — GPAC-Schwachstelle bei Sphärendefinition.

---

Referenzen

1. MITRE Corporation. "CWE-673: External Influence of Sphere Definition." https://cwe.mitre.org/data/definitions/673.html

2. OWASP. "Authorization Testing." https://owasp.org/www-project-web-security-testing-guide/latest/4-Web_Application_Security_Testing/05-Authorization_Testing/

3. NIST. "Access Control Policy and Implementation Guides." https://csrc.nist.gov/publications/detail/sp/800-192/final