Fabriquer un système de gestion d'autorisations avec Zend Framework

Introduction à l'autorisation

Après qu'un utilisateur se soit authentifié, une application peut proposer différentes règles d'accès à ses différentes ressources (parties). Le procédé qui consiste à savoir "qui a le droit de faire quoi" est nommé "gestion des autorisations". Dans sa forme la plus simple l'autorisation est la composition de trois facteurs:

  • l'identitié de la personne souhaitant des droits - le rôle (qui?)

  • la ressource demandée (sur quoi?)

  • et optionnellement le privilège - le droit (quoi?)

Dans Zend Framework, le composant Zend_Acl vous propose de créer ces trois entités remarquables, de les associer et de les interroger dans le futur.

Utilisation de base de Zend_Acl

En utilisant Zend_Acl, n'importe quel modèle peut servir de rôle ou de ressource en implémentant l'interface adéquate. Pour créer des rôles, implémentez Zend_Acl_Role_Interface, qui définit la méthode getRoleId(). Pour créer des ressources, implémentez Zend_Acl_Resource_Interface qui définit la méthode getResourceId().

Nous allons faire une démonstration avec un modèle simple. On peut le relier avec notre système d'ACL en implémentant Zend_Acl_Role_Interface. La méthode getRoleId() retournera "guest" lorsque l'ID est inconnu, ou l'ID du rôle lorsque celui-ci aura été affecté. Cette valeur peut provenir de n'importe où, probablement qu'elle proviendra d'une définition faite en base de données.

  1. class Default_Model_User implements Zend_Acl_Role_Interface
  2. {
  3.     protected $_aclRoleId = null;
  4.  
  5.     public function getRoleId()
  6.     {
  7.         if ($this->_aclRoleId == null) {
  8.             return 'guest';
  9.         }
  10.  
  11.         return $this->_aclRoleId;
  12.     }
  13. }

Le concept des utilisateurs ayant des rôles est simple à comprendre, mais l'application peut consommer plusieurs modèles et en retrouver des "ressources" qui seront consommables par les rôles. Nous utiliserons simplement des billets de blog comme ressources dans nos exemples, et comme les ressources sont des objets, nous ferons en sorte que l'ID d'un billet blog soir 'blogPost', naturellement cette valeur peut être calculée dynamiquement en fonction du besoin.

  1. class Default_Model_BlogPost implements Zend_Acl_Resource_Interface
  2. {
  3.     public function getResourceId()
  4.     {
  5.         return 'blogPost';
  6.     }
  7. }

Maintenant que nous avons au minimum un rôle et une ressource, définissons règles qui les lient. Ces règles seront lues lorsque le système recevra une requête d'acl demandant ce qu'il est possible de faire avec tel rôle, telle ressource et éventuellement tel privilège.

Imaginons les règles suivantes:

  1. $acl = new Zend_Acl();
  2.  
  3. // mise en place des rôles
  4. $acl->addRole('guest');
  5. // owner hérite du rôle guest
  6. $acl->addRole('owner', 'guest');
  7.  
  8. // ajout de ressources
  9. $acl->addResource('blogPost');
  10.  
  11. // ajout de privilèges liant des rôles et des ressources
  12. $acl->allow('guest', 'blogPost', 'view');
  13. $acl->allow('owner', 'blogPost', 'post');
  14. $acl->allow('owner', 'blogPost', 'publish');

Les règles ci-dessus sont très simples: deux rôles "guest"(invité) et "owner" (propriétaire), et une ressource "blogPost"(billet). Les invités sont autorisés à voir les billets, les propriétaires peuvent poster et publier des billets. Pour requêter le système, procédez alors comme suit:

  1. // Imaginons que le modèle User soit de type "guest"
  2. $guestUser = new Default_Model_User();
  3. $ownerUser = new Default_Model_Owner('OwnersUsername');
  4.  
  5. $post = new Default_Model_BlogPost();
  6.  
  7. $acl->isAllowed($guestUser, $post, 'view'); // true
  8. $acl->isAllowed($ownerUser, $post, 'view'); // true
  9. $acl->isAllowed($guestUser, $post, 'post'); // false
  10. $acl->isAllowed($ownerUser, $post, 'post'); // true

Comme vous pouvez le voir le système répond comme il faut dans la mesure où les invités peuvent lire les billets mais seuls les propriétaires peuvent en ajouter. Cependant ce système peut sembler manquer de dynamisme. Comment vérifier qu'un utilisateur spécifique est bien propriétaire d'un billet spécifique avant de l'autoriser à le publier ? Autrement dit, on veut s'assurer que seuls les propriétaires des billets peuvent publier ceux-ci, et pas ceux des autres.

C'est là qu'entrent en jeu les assertions. Les assertions sont des vérifications supplémentaires à effectuer en même temps que la vérification de la règle d'acl. Ce sont des objets. Utilisons notre exemple avec une assertion:

  1. class OwnerCanPublishBlogPostAssertion implements Zend_Acl_Assert_Interface
  2. {
  3.     /**
  4.      * Cette assertion va recevoir le User et le BlogPost actuels.
  5.      *
  6.      * @param Zend_Acl $acl
  7.      * @param Zend_Acl_Role_Interface $user
  8.      * @param Zend_Acl_Resource_Interface $blogPost
  9.      * @param $privilege
  10.      * @return bool
  11.      */
  12.     public function assert(Zend_Acl $acl,
  13.                            Zend_Acl_Role_Interface $user = null,
  14.                            Zend_Acl_Resource_Interface $blogPost = null,
  15.                            $privilege = null)
  16.     {
  17.         if (!$user instanceof Default_Model_User) {
  18.             throw new Exception(__CLASS__
  19.                               . '::'
  20.                               . __METHOD__
  21.                               . ' s'attend à un rôle'
  22.                               . ' instance de User');
  23.         }
  24.  
  25.         if (!$blogPost instanceof Default_Model_BlogPost) {
  26.             throw new Exception(__CLASS__
  27.                               . '::'
  28.                               . __METHOD__
  29.                               . ' s'attend à un rôle'
  30.                               . ' instance de BlogPost');
  31.         }
  32.  
  33.         // Si le rôle est publisher, il peut toujours modifier son billet
  34.         if ($user->getRoleId() == 'publisher') {
  35.             return true;
  36.         }
  37.  
  38.         // vérifions que qui que ce soit, il modifie uniquement ses propres billets
  39.         if ($user->id != null && $blogPost->ownerUserId == $user->id) {
  40.             return true;
  41.         } else {
  42.             return false;
  43.         }
  44.     }
  45. }

Pour faire intervenir l'assertion dans les ACL, nous les utilisons comme ceci:

  1. // remplacez ceci:
  2. //   $acl->allow('owner', 'blogPost', 'publish');
  3. // par cela:
  4. $acl->allow('owner',
  5.             'blogPost',
  6.             'publish',
  7.             new OwnerCanPublishBlogPostAssertion());
  8.  
  9. // ajoutons aussi le rôle "publisher" qui a accès à tout
  10. $acl->allow('publisher', 'blogPost', 'publish');

Maintenant, dès que l'ACL est consultée pour savoir si un propriétaire peut publier un billet, cette assertion sera vérifiée. Elle s'assure que sauf si le rôle est 'publisher' le propriétaire a bien écrit le billet. Dans cet exemple, nous vérifions pour savoir si l'attribut ownerUserId du billet correspond à l'identifiant de l'utilisateur en question.

blog comments powered by Disqus