Implémentation d'un système RBAC dynamique pour les applications d'entreprise - Simplifiée

Introduction

Dans le paysage numérique actuel, une gestion efficace des accès est essentielle pour sécuriser les ressources et les données. Un système de contrôle d'accès basé sur les rôles (RBAC) fournit une approche structurée pour gérer les autorisations et les rôles des utilisateurs. Ce blog présente deux variantes de systèmes RBAC adaptées aux différents besoins des applications : les applications métier communes et les applications métier d'entreprise.

Pour illustrer les concepts, nous fournirons un extrait de code de démonstration pour un service gérant le contrôle d'accès, ainsi qu'une description détaillée de chaque table utilisée dans le système RBAC.

Composants du système RBAC

Applications métiers courantes

Pour les applications métiers les plus courantes, le système RBAC peut être rationalisé pour gérer efficacement les rôles et les autorisations sans complexités supplémentaires. Les éléments clés sont :

1. Tableau des utilisateurs

   • Objectif : stocke les informations utilisateur telles que le nom d'utilisateur, le hachage du mot de passe, l'adresse e-mail et le niveau d'autorisation.
   • Colonnes clés : user_id, username, password_hash, email, Department, Clearance_level

2. Tableau des rôles

   • Objectif : définit les rôles au sein de l'application, en détaillant le nom et la description de chaque rôle.
   • Colonnes clés : role_id, role_name, description

3. Tableau des modules

   • Objectif : répertorie les modules d'application ou les ressources, décrivant leur objectif et leurs fonctionnalités.
   • Colonnes clés : module_id, module_name, description

4. Tableau Module_Permission

   • Objectif : Spécifie les autorisations associées à chaque module, telles que l'accès en lecture ou en écriture.
   • Colonnes clés : module_permission_id, module_id, permission_type

5. Tableau Role_Permission

   • Objectif : mappe les rôles aux autorisations des modules, déterminant les actions que les rôles peuvent effectuer sur les modules.
   • Colonnes clés : role_permission_id, role_id, module_permission_id

6. Tableau User_Role

   • Objectif : gère la relation entre les utilisateurs et les rôles, permettant un contrôle d'accès basé sur les rôles.
   • Colonnes clés : user_role_id, user_id, role_id

Applications métiers d'entreprise

Les applications métiers d'entreprise peuvent nécessiter des composants supplémentaires pour répondre à des besoins de contrôle d'accès plus complexes. Ceux-ci incluent :

1. Tableau des politiques

   • Objectif : définit des règles et conditions d'accès supplémentaires, offrant un contrôle plus granulaire.
   • Colonnes clés : Policy_id, Policy_name, description

2. Tableau Role_Policy

   • Objectif : relie les rôles aux politiques, permettant aux rôles d'être régis par des règles et des conditions spécifiques.
   • Colonnes clés : role_policy_id, role_id, Policy_id

3. Tableau User_Policy

   • Objectif : attribue des stratégies directement aux utilisateurs, en tenant compte des autorisations individuelles.
   • Colonnes clés : user_policy_id, user_id, Policy_id

4. Tableau Policy_Condition

   • Objectif : spécifie les conditions des stratégies, telles que les contraintes contextuelles ou basées sur les attributs.
   • Colonnes clés : Policy_condition_id, Policy_id, condition_type, condition_value

5. Tableau Contextual_Permission

   • Objectif : applique des politiques basées sur des contextes spécifiques, comme le service ou l'emplacement de l'utilisateur.
   • Colonnes clés : contextual_permission_id, Policy_id, context_type, context_value

6. Tableau de contraintes_temporelles

   • Objectif : gère l'accès temporel, en définissant les heures de début et de fin pour l'efficacité des politiques.
   • Colonnes clés : temporal_constraint_id, Policy_id, start_time, end_time

7. Tableau des délégations

   • Objectif : facilite l'attribution de rôles temporaires, permettant aux utilisateurs de déléguer des rôles avec des dates d'expiration spécifiées.
   • Colonnes clés : délégation_id, délégué_user_id, delegator_user_id, role_id, délégué_at, expiration_date

8. Tableau Audit_Log

   • Objectif : enregistre les actions des utilisateurs, les interactions avec les modules et les changements de rôle pour l'audit de sécurité et de conformité.
   • Colonnes clés : audit_log_id, user_id, action, module_id, role_id, timestamp, détails

Code de démonstration : service de contrôle d'accès

Voici un exemple d'implémentation d'un AccessControlService en Java, démontrant comment gérer le contrôle d'accès dans un système RBAC dynamique. Cet exemple couvre les composants essentiels et illustre comment gérer les autorisations et les politiques.

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

Conclusion

En faisant la différence entre les applications métier courantes et les applications métier d'entreprise, vous pouvez personnaliser votre système RBAC

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!