为企业应用程序实施动态 RBAC 系统

为企业应用程序实施动态 rbac 系统 - 简化

介绍

在当今的数字环境中，有效的访问管理对保护资源和数据至关重要。基于角色的访问控制 (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_权限表
- 用途:根据具体的上下文应用策略，如用户部门或位置。
- 关键列：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 表
- 用途：记录用户操作、模块交互和角色变更，以审查安全性和合规性。
- 关键列：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 &amp;&amp; modulePermission.getModuleId().equals(moduleId) &amp;&amp; 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 &amp;&amp; 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 &amp;&amp; modulePermission.getModuleId().equals(moduleId) &amp;&amp; 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;
    }
}
</temporalconstraint></contextualpermission></policycondition></rolepolicy></userrole></userpolicy></rolepermission></delegation></rolepermission></userrole>

结论

您可以通过区分普通业务应用和企业业务应用来定制您的rbac系统

以上是企业应用程序的动态实施 RBAC 系统 - 详情请关注图灵教育的其他相关文章！

为企业应用程序实施动态 RBAC 系统 - 简化

精品课程

技术教程

图灵资讯

图灵内推

图灵公众号