sql - Quelle est la meilleure façon de gérer plusieurs types d'autorisation?

Translate

Je rencontre souvent le scénario suivant dans lequel je dois offrir de nombreux types d'autorisations. J'utilise principalement ASP.NET / VB.NET avec SQL Server 2000.

Scénario

Je souhaite proposer un système d'autorisation dynamique qui peut fonctionner sur différents paramètres. Disons que je souhaite donner à un service ou à une personne en particulier l'accès à une application. Et prétendez que nous avons un certain nombre d'applications qui ne cessent de croître.

Dans le passé, j'ai choisi l'une des deux façons suivantes que je connais pour le faire.

  1. Utilisez une table d'autorisations unique avec des colonnes spéciales utilisées pour déterminer comment appliquer les paramètres. Les colonnes spéciales de cet exemple sont TypeID et TypeAuxID. Le SQL ressemblerait à quelque chose comme ça.

    SELECT COUNT(PermissionID)
    FROM application_permissions
    WHERE
    (TypeID = 1 AND TypeAuxID = @UserID) OR
    (TypeID = 2 AND TypeAuxID = @DepartmentID)
    AND ApplicationID = 1
    
  2. Utilisez une table de mappage pour chaque type d'autorisation, puis joignez-les toutes ensemble.

    SELECT COUNT(perm.PermissionID)
    FROM application_permissions perm
    LEFT JOIN application_UserPermissions emp
    ON perm.ApplicationID = emp.ApplicationID
    LEFT JOIN application_DepartmentPermissions dept
    ON perm.ApplicationID = dept.ApplicationID
    WHERE [email protected]
      AND ([email protected] OR [email protected] OR
     (emp.UserID IS NULL AND dept.DeptID IS NULL)) AND ApplicationID = 1
    ORDER BY q.QID ASC
    

Mes pensées

J'espère que les exemples ont du sens. Je les ai bricolés ensemble.

Le premier exemple nécessite moins de travail, mais aucun d'eux ne semble être la meilleure réponse. Y a-t-il une meilleure façon de gérer cela?

This question and all comments follow the "Attribution Required."

Toutes les réponses

Translate

Je suis d'accord avec John Downey.

Personnellement, j'utilise parfois une énumération de permissions avec indicateur. De cette façon, vous pouvez utiliser les opérations binaires AND, OR, NOT et XOR sur les éléments de l'énumération.

"[Flags]
public enum Permission
{
    VIEWUSERS = 1, // 2^0 // 0000 0001
    EDITUSERS = 2, // 2^1 // 0000 0010
    VIEWPRODUCTS = 4, // 2^2 // 0000 0100
    EDITPRODUCTS = 8, // 2^3 // 0000 1000
    VIEWCLIENTS = 16, // 2^4 // 0001 0000
    EDITCLIENTS = 32, // 2^5 // 0010 0000
    DELETECLIENTS = 64, // 2^6 // 0100 0000
}"

Ensuite, vous pouvez combiner plusieurs autorisations à l'aide de l'opérateur binaire AND.

Par exemple, si un utilisateur peut afficher et modifier des utilisateurs, le résultat binaire de l'opération est 0000 0011 qui converti en décimal est 3.
Vous pouvez ensuite stocker l'autorisation d'un utilisateur dans une seule colonne de votre base de données (dans notre cas, ce serait 3).

Dans votre application, vous avez juste besoin d'une autre opération au niveau du bit (OR) pour vérifier si un utilisateur a une autorisation particulière ou non.

La source
Translate

La façon dont j'utilise généralement le codage des systèmes d'autorisation consiste à avoir 6 tables.

  • Utilisateurs - c'est assez simple, c'est votre table d'utilisateurs typique
  • Groupes - ce serait également pour vos départements
  • Rôles - il s'agit d'une table avec toutes les autorisations, comprenant généralement un nom lisible par l'homme et une description
  • Users_have_Groups - il s'agit d'un tableau plusieurs-à-plusieurs des groupes auxquels appartient un utilisateur
  • Users_have_Roles - une autre table plusieurs-à-plusieurs des rôles attribués à un utilisateur individuel
  • Groups_have_Roles - le dernier tableau plusieurs-à-plusieurs des rôles de chaque groupe

Au début d'une session d'utilisateurs, vous exécuteriez une logique qui extrait chaque rôle qu'ils ont attribué, que ce soit dans un répertoire ou via un groupe. Ensuite, vous codez sur ces rôles en tant qu'autorisations de sécurité.

Comme je l'ai dit, c'est ce que je fais généralement, mais votre millage peut varier.

La source
Translate

En plus des solutions de John Downey et de jdecuyper, j'ai également ajouté un bit "Explicit Deny" à la fin / au début du champ de bits, afin que vous puissiez effectuer des autorisations supplémentaires par groupe, appartenance au rôle, puis soustraire des autorisations basées sur un refus explicite entrées, tout comme NTFS fonctionne, en ce qui concerne les autorisations.

La source
Translate

Honnêtement, les fonctionnalités d'appartenance / rôles ASP.NET fonctionneraient parfaitement pour le scénario que vous avez décrit. Écrire vos propres tables / procs / classes est un excellent exercice et vous pouvez obtenir un très bon contrôle sur les moindres détails, mais après avoir fait cela moi-même, j'ai conclu qu'il était préférable d'utiliser simplement les éléments .NET intégrés. Un grand nombre de code existant est conçu pour contourner ce qui est bien. L'écriture à partir de zéro m'a pris environ 2 semaines et ce n'était pas aussi robuste que les .NET. Vous devez coder tellement de conneries (récupération de mot de passe, verrouillage automatique, cryptage, rôles, une interface d'autorisation, des tonnes de processus, etc.) et le temps pourrait être mieux dépensé ailleurs.

Désolé si je n'ai pas répondu à votre question, je suis comme le gars qui dit d'apprendre c # quand quelqu'un pose une question vb.

La source
Translate

Une approche que j'ai utilisée dans diverses applications consiste à avoir une classe PermissionToken générique qui a une propriété Value modifiable. Ensuite, vous interrogez l'application demandée, elle vous indique quels PermissionTokens sont nécessaires pour l'utiliser.

Par exemple, l'application d'expédition peut vous indiquer qu'elle a besoin:

new PermissionToken()
{
    Target = PermissionTokenTarget.Application,
    Action = PermissionTokenAction.View,
    Value = "ShippingApp"
};

Cela peut évidemment être étendu à Créer, Modifier, Supprimer, etc. YMMV, mais cela a toujours été une méthode efficace pour moi que j'ai trouvé pour bien évoluer.

La source