Implementierung eines dynamischen RBAC-Systems für Unternehmensanwendungen

Implementing a Dynamic RBAC System for Enterprise Applications - Simplified

Einführung

In der heutigen digitalen Landschaft ist eine effektive Zugriffsverwaltung für die Sicherung von Ressourcen und Daten von entscheidender Bedeutung. Ein rollenbasiertes Zugriffskontrollsystem (RBAC) bietet einen strukturierten Ansatz zur Verwaltung von Benutzerberechtigungen und -rollen. In diesem Blog werden zwei Varianten von RBAC-Systemen beschrieben, die auf unterschiedliche Anwendungsanforderungen zugeschnitten sind: Common Business Applications und Enterprise Business Applications.

Zur Veranschaulichung der Konzepte stellen wir ein Demo-Code-Snippet für einen Dienst zur Verfügung, der die Zugriffskontrolle verwaltet, sowie eine detaillierte Beschreibung jeder im RBAC-System verwendeten Tabelle.

RBAC-Systemkomponenten

Gängige Geschäftsanwendungen

Für die meisten gängigen Geschäftsanwendungen kann das RBAC-System optimiert werden, um Rollen und Berechtigungen effektiv und ohne zusätzliche Komplexität zu verwalten. Die Schlüsselkomponenten sind:

Benutzertabelle
- Zweck: Speichert Benutzerinformationen wie Benutzername, Passwort-Hash, E-Mail und Freigabestufe.
- Schlüsselspalten: Benutzer-ID, Benutzername, Passwort-Hash, E-Mail, Abteilung, Freigabeebene
Rollentabelle
- Zweck: Definiert Rollen innerhalb der Anwendung und gibt den Namen und die Beschreibung jeder Rolle an.
- Schlüsselspalten: Rollen-ID, Rollenname, Beschreibung
Modultabelle
- Zweck: Listet Anwendungsmodule oder Ressourcen auf und beschreibt deren Zweck und Funktionalität.
- Schlüsselspalten: Modul-ID, Modulname, Beschreibung
Module_Permission Table
- Zweck: Gibt die mit jedem Modul verbundenen Berechtigungen an, z. B. Lese- oder Schreibzugriff.
- Schlüsselspalten: module_permission_id, module_id, freedom_type
Role_Permission Table
- Zweck: Ordnet Rollen Modulberechtigungen zu und bestimmt, welche Aktionen Rollen auf Modulen ausführen können.
- Schlüsselspalten: Role_permission_id, Role_id, module_permission_id
Benutzerrollentabelle
- Zweck: Verwaltet die Beziehung zwischen Benutzern und Rollen und ermöglicht eine rollenbasierte Zugriffskontrolle.
- Schlüsselspalten: user_role_id, user_id, role_id

Geschäftsanwendungen für Unternehmen

Geschäftsanwendungen für Unternehmen erfordern möglicherweise zusätzliche Komponenten, um komplexere Zugriffskontrollanforderungen zu erfüllen. Dazu gehören:

Richtlinientabelle
- Zweck: Definiert zusätzliche Zugriffsregeln und -bedingungen und sorgt für eine detailliertere Kontrolle.
- Schlüsselspalten: Richtlinien-ID, Richtlinienname, Beschreibung
Role_Policy Table
- Zweck: Verknüpft Rollen mit Richtlinien und ermöglicht so die Steuerung von Rollen durch bestimmte Regeln und Bedingungen.
- Schlüsselspalten: Role_policy_id, Role_id, Policy_id
Benutzerrichtlinientabelle
- Zweck: Weist Benutzern Richtlinien direkt zu und berücksichtigt individuelle Berechtigungen.
- Schlüsselspalten: user_policy_id, user_id, Policy_id
Policy_Condition Table
- Zweck: Gibt Bedingungen für Richtlinien an, z. B. kontextbezogene oder attributbasierte Einschränkungen.
- Schlüsselspalten: Policy_condition_id, Policy_id, Condition_type, Condition_value
Contextual_Permission Table
- Zweck: Wendet Richtlinien basierend auf bestimmten Kontexten an, z. B. Benutzerabteilung oder Standort.
- Schlüsselspalten: contextual_permission_id, Policy_id, context_type, context_value
Temporal_Constraint-Tabelle
- Zweck: Verwaltet den zeitbasierten Zugriff und definiert Start- und Endzeiten für die Wirksamkeit von Richtlinien.
- Schlüsselspalten: temporal_constraint_id, Policy_id, start_time, end_time
Delegationstisch
- Zweck: Erleichtert temporäre Rollenzuweisungen, sodass Benutzer Rollen mit bestimmten Ablaufdaten delegieren können.
- Schlüsselspalten: Delegations-ID, Delegations-Benutzer-ID, Delegations-Benutzer-ID, Rollen-ID, Delegationsat, Ablaufdatum
Audit_Log-Tabelle
- Zweck: Zeichnet Benutzeraktionen, Modulinteraktionen und Rollenänderungen für Sicherheits- und Compliance-Überprüfungen auf.
- Schlüsselspalten: audit_log_id, user_id, action, module_id, role_id, timestamp, details

Democode: Zugangskontrolldienst

Hier ist eine Beispielimplementierung eines AccessControlService in Java, die zeigt, wie die Zugriffskontrolle in einem dynamischen RBAC-System verwaltet wird. Dieses Beispiel deckt die wesentlichen Komponenten ab und veranschaulicht, wie mit Berechtigungen und Richtlinien umgegangen wird.

import java.time.LocalDateTime;
import java.util.List;

@Service
@Transactional
public class AccessControlService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private RoleRepository roleRepository;

    @Autowired
    private ModulePermissionRepository modulePermissionRepository;

    @Autowired
    private RolePermissionRepository rolePermissionRepository;

    @Autowired
    private UserRoleRepository userRoleRepository;

    @Autowired
    private PolicyRepository policyRepository;

    @Autowired
    private UserPolicyRepository userPolicyRepository;

    @Autowired
    private RolePolicyRepository rolePolicyRepository;

    @Autowired
    private PolicyConditionRepository policyConditionRepository;

    @Autowired
    private ContextualPermissionRepository contextualPermissionRepository;

    @Autowired
    private TemporalConstraintRepository temporalConstraintRepository;

    @Autowired
    private DelegationRepository delegationRepository;

    public boolean hasAccess(String username, Long moduleId, String permissionType) {
        // Fetch user
        User user = userRepository.findByUsername(username);
        if (user == null) {
            return false;
        }

        // Check if user has any delegations
        boolean hasDelegatedAccess = checkDelegatedAccess(user.getUserId(), moduleId, permissionType);
        if (hasDelegatedAccess) {
            return true;
        }

        // Check if user has direct access via roles
        List<UserRole> userRoles = userRoleRepository.findByUserId(user.getUserId());
        for (UserRole userRole : userRoles) {
            List<RolePermission> rolePermissions = rolePermissionRepository.findByRoleId(userRole.getRoleId());
            for (RolePermission rolePermission : rolePermissions) {
                ModulePermission modulePermission = modulePermissionRepository.findById(rolePermission.getModulePermissionId()).orElse(null);
                if (modulePermission != null && modulePermission.getModuleId().equals(moduleId) && modulePermission.getPermissionType().equals(permissionType)) {
                    // Check if role has any associated policies
                    if (hasPolicyAccess(user.getUserId(), moduleId, permissionType, modulePermission.getModuleId())) {
                        return true;
                    }
                }
            }
        }

        return false;
    }

    private boolean checkDelegatedAccess(Long userId, Long moduleId, String permissionType) {
        List<Delegation> delegations = delegationRepository.findByDelegateUserId(userId);
        LocalDateTime now = LocalDateTime.now();
        for (Delegation delegation : delegations) {
            // Check if delegation is expired
            if (delegation.getExpirationDate() != null && delegation.getExpirationDate().isBefore(now)) {
                continue;
            }

            List<RolePermission> rolePermissions = rolePermissionRepository.findByRoleId(delegation.getRoleId());
            for (RolePermission rolePermission : rolePermissions) {
                ModulePermission modulePermission = modulePermissionRepository.findById(rolePermission.getModulePermissionId()).orElse(null);
                if (modulePermission != null && modulePermission.getModuleId().equals(moduleId) && modulePermission.getPermissionType().equals(permissionType)) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean hasPolicyAccess(Long userId, Long moduleId, String permissionType, Long modulePermissionId) {
        // Check policies assigned directly to the user
        List<UserPolicy> userPolicies = userPolicyRepository.findByUserId(userId);
        for (UserPolicy userPolicy : userPolicies) {
            if (isPolicyValid(userPolicy.getPolicyId(), moduleId, permissionType)) {
                return true;
            }
        }

        // Check policies assigned to roles
        List<UserRole> userRoles = userRoleRepository.findByUserId(userId);
        for (UserRole userRole : userRoles) {
            List<RolePolicy> rolePolicies = rolePolicyRepository.findByRoleId(userRole.getRoleId());
            for (RolePolicy rolePolicy : rolePolicies) {
                if (isPolicyValid(rolePolicy.getPolicyId(), moduleId, permissionType)) {
                    return true;
                }
            }
        }

        return false;
    }

    private boolean isPolicyValid(Long policyId, Long moduleId, String permissionType) {
        // Check policy conditions
        List<PolicyCondition> conditions = policyConditionRepository.findByPolicyId(policyId);
        for (PolicyCondition condition : conditions) {
            // Add logic to evaluate conditions based on conditionType and conditionValue
            // e.g., Check if context or attribute matches the condition
        }

        // Check contextual permissions
        List<ContextualPermission> contextualPermissions = contextualPermissionRepository.findByPolicyId(policyId);
        for (ContextualPermission contextualPermission : contextualPermissions) {
            // Add logic to evaluate contextual permissions
            // e.g., Check if current context matches the contextualPermission
        }

        // Check temporal constraints
        List<TemporalConstraint> temporalConstraints = temporalConstraintRepository.findByPolicyId(policyId);
        for (TemporalConstraint temporalConstraint : temporalConstraints) {
            LocalDateTime now = LocalDateTime.now();
            if (now.isBefore(temporalConstraint.getStartTime()) || now.isAfter(temporalConstraint.getEndTime())) {
                return false;
            }
        }

        return true;
    }
}

Nach dem Login kopieren

Abschluss

Durch die Unterscheidung zwischen allgemeinen Geschäftsanwendungen und Unternehmensanwendungen können Sie Ihr RBAC-System individuell anpassen

Das obige ist der detaillierte Inhalt vonImplementierung eines dynamischen RBAC-Systems für Unternehmensanwendungen – vereinfacht. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!