Comment concevoir un hiérarchiques basées sur le rôle de système de contrôle d'accès

Accord de base est que nous avons une coutume construit "kickstart" pour nos projets. Pour cela, nous sommes à la recherche à refaire le contrôle de l'utilisateur. Je sais qu'il y a beaucoup de questions sur le général rbac, mais je ne trouve aucune sur hiérarchique rbac?

Nos exigences sont les suivantes:

Rôles peuvent être attribués à des autorisations de groupe
Si le rôle ne dispose pas d'une autorisation d'entrée, puis il est automatiquement refusé
Un utilisateur peut être donnée primordiale autorisations
Un utilisateurs primordial des autorisations est soit d'accorder ou de refuser
Si un utilisateur est expressément refusé une permission n'importe quels rôles dire "accordé" le remplacement des victoires.
Les utilisateurs peuvent avoir plusieurs rôles
Rôles peut avoir de hiérarchie
Rôles ne peut hériter que d'autres rôles (par exemple, Un "Forum Super Modérateur" rôle "Modérateur du Forum", et un "Système de Responsable", et le "Modérateur du Forum" rôle déjà hérite de la "Utilisateur du Forum" rôle )
Rôles qui héritent d'un autre rôle que de refuser ou d'accorder un privilège de remplacer leur enfant la permission
Autorisations sont regroupés par "module" (par exemple, un "Blog" module peut avoir une "modifier l'entrée" de l'autorisation, et un "Forum" module peut avoir une "modifier l'entrée" permission et ils seront pas en conflit)
Il y a un "Tout et Rien" autorisation qu'il accorde automatiquement un accès complet

Donc, avec les exigences de la route, voici comment je pense à le faire.

Tableau: Les Utilisateurs

id            | int     | unique id

Table: Rôles

id            | int     | unique id
-------------- | ---------------------------------------------
title         | varchar | human readable name

Table: Autorisations

id            | int     | unique id
-------------- | ---------------------------------------------
module        | varchar | module name
-------------- | ---------------------------------------------
title         | varchar | human readable name
-------------- | ---------------------------------------------
key           | varchar | key name used in functions

Table: Role_User

role_id       | int     | id from roles table
-------------- | ---------------------------------------------
user_id       | int     | id from users table

Table: Permission_Role

id            | int     | unique id
-------------- | ---------------------------------------------
permission_id | int     | id from permissions table
-------------- | ---------------------------------------------
role_id       | int     | id from roles table
-------------- | ---------------------------------------------
grant         | tinyint | 0 = deny, 1 = grant

Table: Permission_User

id            | int     | unique id
-------------- | ---------------------------------------------
permission_id | int     | id from permissions table
-------------- | ---------------------------------------------
user_id       | int     | id from users table
-------------- | ---------------------------------------------
grant         | tinyint | 0 = deny, 1 = grant

Bien, en fait, c'est la moitié, la partie je suis sûr de la partie, je suis coincé sur est la hiérarchie des rôles.

Alors, comment puis-je concevoir ce?
Mon idée est que, pour économiser sur les requêtes de base de données, je vais me contenter de construire l'autorisation de la matrice de connexion, et l'enregistrer à la séance pour que les requêtes n'ont pas à être aussi simples qu'elles le sont uniquement exécuté une fois pour chaque connexion.

Le problème que je vois est que, je vais avoir besoin de savoir la hiérarchie des rôles afin que je puisse résoudre le héritée des rôles des autorisations avant de me résoudre la hériter.

Les autorisations de l'utilisateur est la partie la plus facile, la par-les autorisations de l'utilisateur sont essentiellement les enfin résolu groupe.

Est-il une raison pourquoi user ont pas role, mais ont permission? C'est un "permisson modèle", pas de "modèle", n'est-ce pas? Avec cette approche, les rôles ne sont pas utilisées n'importe où.
Oups, j'ai Oublié d'ajouter que la table, édité!
Pourtant, je pense que il n'y a aucune raison pour user avoir permission. Il pourrait avoir roles avec permissions, mais pas permissions comme ils sont. Cette chose ruiner la logique (à mon humble avis).
Un utilisateur lui-même peut également être donné les autorisations, ces autorisations de remplacer tous les rôles, ils sont. Il évite d'avoir à créer de nouveaux rôles avec une autorisation simplement parce que vous voulez que l'Utilisateur X pour être capable de faire une action supplémentaire. Ou si l'utilisateur a été de faire quelque chose qu'ils ne devraient pas, vous pouvez rapidement le nier pour cet utilisateur. Sinon, vous devrait hériter le niveau le plus élevé de rôle puis nier qu'il qui peut être gênant.
C'est un peu comme dire que chaque utilisateur est son propre rôle qui hérite automatiquement de tous les autres rôle de l'utilisateur a été donné sans avoir à créer un groupe pour l'utilisateur. Cela fait-il sens?
Oui. Cela a du sens.

InformationsquelleAutor Hailwood | 2013-04-22

50

Il existe un moyen de mettre en œuvre le rôle de l'héritage par l'utilisation récursive de la relation sur la table Roles, par le rôle de référence à un autre enregistrement:

Cette relation va ajouter 1 : n héritage dans Roles enregistrement. Vous pouvez obtenir l'ensemble de la hiérarchie de l'arbre avec cette fonction stockée:
```
CREATE FUNCTION `getHierarchy`(`aRole` BIGINT UNSIGNED)
RETURNS VARCHAR(1024)
NOT DETERMINISTIC
READS SQL DATA
BEGIN
DECLARE `aResult` VARCHAR(1024) DEFAULT NULL;
DECLARE `aParent` BIGINT UNSIGNED;

SET `aParent` = (SELECT `parent` FROM `Roles` WHERE `id` = `aRole`);

WHILE NOT `aParent` IS NULL DO

    SET `aResult` = CONCAT_WS(',', `aResult`, `aParent`);
    SET `aParent` = (SELECT `parent` FROM `Roles` WHERE `id` = `aParent`);

END WHILE;

RETURN IFNULL(`aResult`, '');
END
```
Ensuite, vous pouvez obtenir tous les accordée autorisations avec quelque chose comme ceci:
```
SELECT
    `permission_id`
FROM
    `Permission_Role`
WHERE
    FIND_IN_SET(`role_id`, `getHierarchy`({$role}))
    AND
    grant;
```
Si c'est pas assez, alors vous pourriez faire une autre table pour l'héritage:

Mais, dans ce cas, besoin d'une autre hiérarchie de l'obtention de l'algorithme.

Pour résoudre primordial problème, vous devrez obtenir les autorisations du rôle et des autorisations de l'utilisateur. Ensuite, écrire user autorisations sur roles autorisations session.

Aussi, je suggère de supprimer grant colonnes dans Permission_Role et Permission_User. Il n'est pas nécessaire de carte chaque autorisation pour chacun d'eux. Juste assez pour utiliser EXISTS requêtes: si il y a un enregistrement, puis l'autorisation accordée, d'autre - il n'est pas. Si vous avez besoin de récupérer toutes les autorisations et les statuts, vous pouvez utiliser LEFT JOINs.
- Cela sonne bien, je vais le regarder, je suis à la recherche à chaque rôle d'hériter de plusieurs autres rôles, de sorte que vous avez à travailler hors de l'autre algorithme, aussi vous vous demandez comment faire si nous ne pouvons pas créer des procédures stockées? Point d'accorder ou de refuser n'est pas à chaque liste d'autorisation, d'un point pour accorder ou refuser est que Si un rôle hérite d'un autre rôle, si hérité du rôle a été accordée l'autorisation, vous pouvez refuser explicitement dans l'héritage rôle de refuser l'autorisation.
InformationsquelleAutor BlitZ

Vous devez vous connecter pour publier un commentaire.