為企業應用程式實施動態 RBAC 系統 - 簡化-java教程-PHP中文網

Implementing a Dynamic RBAC System for Enterprise Applications - Simplified

介紹

在當今的數位環境中，有效的存取管理對於保護資源和資料至關重要。基於角色的存取控制 (RBAC) 系統提供了一種結構化方法來管理使用者權限和角色。本部落格概述了針對不同應用程式需求量身定制的 RBAC 系統的兩種變體：通用業務應用程式和企業業務應用程式。

為了說明這些概念，我們將提供管理存取控制的服務的演示程式碼片段，以及 RBAC 系統中使用的每個表的詳細說明。

RBAC 系統組件

常見業務應用

對於大多數常見的業務應用程序，可以簡化 RBAC 系統以有效地管理角色和權限，而不會增加複雜性。關鍵組件是：

使用者表
- 用途：儲存使用者訊息，例如使用者名稱、密碼雜湊、電子郵件和權限等級。
- 關鍵列：user_id、使用者名稱、password_hash、電子郵件、部門、clearance_level
角色表
- 用途：定義應用程式中的角色，詳細說明每個角色的名稱和描述。
- 關鍵列：role_id、role_name、description
模組表
- 目的：列出應用程式模組或資源，描述其目的和功能。
- 關鍵欄位： module_id、module_name、description
模組_權限表
- 用途：指定與每個模組關聯的權限，例如讀取或寫入存取權限。
- 關鍵欄位：module_permission_id、module_id、permission_type
角色_權限表
- 用途：將角色對應到模組權限，決定角色可以對模組執行哪些動作。
- 關鍵欄位：role_permission_id、role_id、module_permission_id
使用者角色表
- 用途：管理使用者和角色之間的關係，實現角色為基礎的存取控制。
- 關鍵欄位：user_role_id、user_id、role_id

企業業務應用

企業業務應用程式可能需要額外的元件來處理更複雜的存取控制需求。其中包括：

政策表
- 目的：定義額外的存取規則和條件，提供更精細的控制。
- 關鍵列：policy_id、policy_name、description
角色_策略表
- 目的：將角色與策略連結起來，允許角色受特定規則和條件的約束。
- 關鍵列：role_policy_id、role_id、policy_id
使用者策略表
- 目的：直接向使用者指派策略，適應個人權限。
- 關鍵欄位：user_policy_id、user_id、policy_id
策略_條件表
- 用途：指定策略的條件，例如上下文或基於屬性的限制。
- 關鍵欄位：policy_condition_id、policy_id、condition_type、condition_value
上下文_權限表
- 目的：根據特定情境套用策略，例如使用者部門或位置。
- 關鍵欄位：contextual_permission_id、policy_id、context_type、context_value
Temporal_Constraint 表
- 用途：管理基於時間的訪問，定義策略有效性的開始和結束時間。
- 關鍵欄位：temporal_constraint_id、policy_id、start_time、end_time
代表團表
- 用途：促進臨時角色分配，允許使用者委派具有指定到期日的角色。
- 關鍵欄位：delegation_id、delegate_user_id、delegator_user_id、role_id、delegate_at、expiration_date
審核日誌表
- 用途：記錄使用者操作、模組互動和角色更改，以進行安全性和合規性審核。
- 關鍵列：audit_log_id、user_id、action、module_id、role_id、時間戳記、詳細信息

演示代碼：存取控制服務

這是 Java 中 AccessControlService 的範例實現，示範如何在動態 RBAC 系統中管理存取控制。此範例涵蓋了基本元件並說明如何處理權限和策略。

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;
    }
}

登入後複製