Liste de contrôle d’accès (ACL)¶

Pour commencer¶

L’implémentation par défaut des permissions ACL est propulsé par les bases de données. La base de données CakePHP pour les ACL est composée d’un ensemble de models du cœur et d’une application en mode console qui sont créés lors de votre installation de CakePHP. Les models sont utilisés par CakePHP pour interagir avec votre base de données, afin de stocker et de retrouver les nœuds sous forme d’arbre. L’application en mode console est utilisée pour initialiser votre base de données et interagir avec vos arbres d’ACO et d’ARO.

Pour commencer, vous devrez d’abord être sûr que votre /app/config/database.php est présent et correctement configuré. Voir la section 4.1 pour plus d’information sur la configuration d’une base de données.

Une fois que vous l’avez fait, utilisez la console de CakePHP pour créer vos tables d’ACL :

$ cake schema create DbAcl

Lancer cette commande va supprimer et recréer les tables nécessaires au stockage des informations des ACO et des ARO sous forme d’arbre. La sortie console devrait ressembler à quelque chose comme ça :

---------------------------------------------------------------
Cake Schema Shell
---------------------------------------------------------------

The following tables will be dropped.
acos
aros
aros_acos

Are you sure you want to drop the tables? (y/n)
[n] > y
Dropping tables.
acos updated.
aros updated.
aros_acos updated.

The following tables will be created.
acos
aros
aros_acos

Are you sure you want to create the tables? (y/n)
[y] > y
Creating tables.
acos updated.
aros updated.
aros_acos updated.
End create.

Vous pouvez aussi vous servir du fichier SQL que vous trouverez dans app/config/sql/db_acl.sql, mais ce sera moins sympa.

Quand ce sera fini, vous devriez avoir trois nouvelles tables dans votre système de base de données : acos, aros et aros_acos (la table de jointure pour créer les permissions entre les deux arbres).

Maintenant que nous avons tout configuré, attelons-nous à la création de quelques arbres ARO et ACO.

Créer des Objet Contrôle d’Accès (ACOs) et des Objet Requête d’Accès (AROs)¶

Pour la création de nouveaux objets (ACOs et AROs), il y a deux principales façons de nommer et d’accéder aux noeuds. La première méthode est de lier un objet ACL directement à un enregistrement dans votre base de données en spécifiant le nom du model et la clé étrangère. La seconde méthode peut être utilisée quand un objet n’est pas en relation directe avec un enregistrement de votre base de données - vous pouvez fournir un alias textuel pour l’objet.

Vous voulez créer de nouveaux objets ACL en utilisant le model ACL du coeur de CakePHP. Pour ce faire, il y a un nombre de champs que vous aurez à utiliser pour enregistrer les données : model, foreign_key, alias, et parent_id.

Les champs model et foreign_key pour un objet ACL vous permettent de créer un lien entre les objets qui correspondent à l’enregistrement du model (s’il en est). Par exemple, un certain nombre d’AROs correspondraient aux enregistrements User de la base de données. Il faut configurer la foreign_key pour que l’ID du User vous permette de lier les informations de l’ARO et de l’User avec un seul appel find() au model User avec la bonne association. Réciproquement, si vous voulez gérer les opérations d’édition sur un article spécifique d’un blog ou d’une liste de recette, vous devez choisir de lier un ACO à cet enregistrement spécifique du model.

Un alias est un simple label lisible pour un humain que vous pouvez utiliser pour identifier un objet ACL qui n’est pas en relation directe avec un enregistrement d’un model. Les alias sont couramment utilisés pour nommer les groupes d’utilisateurs ou les collections d’ACOs.

Le parent_id d’un objet ACL vous permet de remplir la structure de l’arbre. Il fournit l’ID du noeud parent dans l’arbre pour créer un nouvel enfant.

Avant que vous ne puissiez créer de nouveaux objets ACL, nous devront charger leurs classes respectives. La façon la plus facile de le faire est d’inclure les components ACL de CakePHP dans le tableau $composents du controller :

public $components = array('Acl');

Quand ce sera fait, nous verrons quelques exemples de création de ces objets. Le code suivant pourrait être placé quelque part dans l’action d’un controller :

Pour rester dans notre configuration de Communauté, nous allons d’abord créer nos groupes d’ARO. Comme nos groupes n’ont pas réellement d’enregistrements spécifiques qui leurs soient reliés, nous allons utiliser les alias pour créer ces objets ACL. Ce que nous faisons ici est en perspective d’une action du controller mais pourrait être fait ailleurs. Ce que nous allons aborder ici est un peu une approche artificielle, mais vous devriez trouver ces techniques plus confortables à utiliser pour créer des AROs et des ACOs à la volée.

Ceci ne devrait rien avoir de radicalement nouveau - nous sommes juste en train d’utiliser les models pour enregistrer les données comme nous le faisons toujours :

public function touteslesActions() {
    $aro =& $this->Acl->Aro;
    // Ici ce sont toutes les informations sur le tableau de notre groupe
    // que nous pouvons itérer comme ceci
    $groups = array(
        0 => array(
        'alias' => 'guerriers'
        ),
        1 => array(
        'alias' => 'magiciens'
        ),
        2 => array(
        'alias' => 'hobbits'
        ),
        3 => array(
        'alias' => 'visiteurs'
      ),
  );
    //Faisons une itération et créons les groupes d'ARO
    foreach($groups as $data) {
        //Pensez à faire un appel à create() au moment d'enregistrer dans
        //la boucle...
        $aro->create();
        //Enregistrement des données
        $aro->save($data);
    }
    //Les autres actions logiques seront à placer ici...
  }

Une fois que nous avons cela, nous pouvons utiliser la console d’application ACL pour vérifier la structure de l’arbre.

$ cake acl view aro

Arbre d'Aro:
---------------------------------------------------------------
  [1]guerriers

  [2]magiciens

  [3]hobbits

  [4]visiteurs

---------------------------------------------------------------

Je suppose qu’il n’y en a pas beaucoup dans l’arbre à ce niveau, mais au minimum quelques vérifications que nous avons faites aux quatres noeuds de niveaux supérieurs. Ajoutons quelques enfants à ces noeuds ARO en ajoutant nos AROs utilisateurs dans ces groupes. Tous les bons citoyens de la Terre du Milieu ont un accompte dans notre nouveau système, nous allons alors lier les enregistrements d’ARO aux enregistrements spécifiques du model de notre base de données.

public function anyAction(){
    $aro = new Aro();
    //Ici nous avons les enregistrement de nos utilisateurs prêts à être liés aux
    //nouveaux enregistrements d'ARO. Ces données peuvent venir d'un model et
    //modifiées, mais nous utiliserons des tableaux statiques pour les besoins de la
    //démonstration.
    $users = array(
        0 => array(
          'alias' => 'Aragorn',
          'parent_id' => 1,
          'model' => 'User',
          'foreign_key' => 2356,
        ),
        1 => array(
          'alias' => 'Legolas',
          'parent_id' => 1,
          'model' => 'User',
          'foreign_key' => 6342,
        ),
        2 => array(
          'alias' => 'Gimli',
          'parent_id' => 1,
          'model' => 'User',
          'foreign_key' => 1564,
        ),
        3 => array(
          'alias' => 'Gandalf',
          'parent_id' => 2,
          'model' => 'User',
          'foreign_key' => 7419,
        ),
        4 => array(
          'alias' => 'Frodo',
          'parent_id' => 3,
          'model' => 'User',
          'foreign_key' => 7451,
        ),
        5 => array(
          'alias' => 'Bilbo',
          'parent_id' => 3,
          'model' => 'User',
          'foreign_key' => 5126,
        ),
        6 => array(
          'alias' => 'Merry',
          'parent_id' => 3,
          'model' => 'User',
          'foreign_key' => 5144,
        ),
        7 => array(
          'alias' => 'Pippin',
          'parent_id' => 3,
          'model' => 'User',
          'foreign_key' => 1211,
        ),
        8 => array(
          'alias' => 'Gollum',
          'parent_id' => 4,
          'model' => 'User',
          'foreign_key' => 1337,
        ),
    );
    //Faisons une itération et créons les AROs (comme des enfants)
    foreach($users as $data){
        //Pensez à faire un appel à create() au moment d'enregistrer dans
        //la boucle...
        $aro->create();
        //Enregistrement des données
        $aro->save($data);
    }
    //Les autres actions logiques se trouveront ici ...
}

La sortie console de cette commande peut maintenant nous intéresser un peu plus. Nous allons faire un essai :

  $ cake acl view aro


Arbre d'Aro:
---------------------------------------------------------------
[1]guerriers

  [5]Aragorn

  [6]Legolas

  [7]Gimli

[2]magiciens

  [8]Gandalf

[3]hobbits

  [9]Frodo

  [10]Bilbo

  [11]Merry

  [12]Pippin

[4]visiteurs

  [13]Gollum


  --------------------------------------------------------------

Maintenant que nous avons notre arbre d’ARO configuré proprement, revenons sur une possible approche de structure d’arbre d’ACO. Alors que nous pouvons structurer plus d’une représentation abstraite de nos ACOs, il est parfois plus pratique de modéliser un arbre ACO après le paramètrage du Controller/Action de CakePHP. Nous avons cinq principaux objets à manipuler dans le scénario de la Communauté, et la configuration naturelle pour cela dans une application CakePHP est un groupe de models, et tout à la fin les controllers qui les manipulent. A côté des controllers eux-mêmes, nous allons vouloir contrôler l’accès à des actions spécifiques dans ces controllers.

Nous allons configurer un arbre d’ACO qui va imiter une configuration d’application CakePHP. Depuis nos cinq ACOs, nous allons créer un arbre d’ACO qui devra ressembler à ça :

• Armes

• Anneaux

• MorceauxPorc

• EffortsDiplomatiques

• Bières

Une bonne chose concernant la configuration des ACL et que chaque ACO va automatiquement contenir quatre propriétés relatives aux actions CRUD (créer, lire, mettre à jour et supprimer). Vous pouvez créer des noeuds enfants sous chacun de ces cinq principaux ACOs, mais l’utilisation des actions de management intégrées à CakePHP permet d’aborder les opérations basiques de CRUD sur un objet donné. Gardez à l’esprit qu’il faudra faire vos arbres d’ACO plus petits et plus faciles à maintenir. Nous allons voir comment ils sont utilisés plus tard quand nous parlerons de la façon d’assigner les permissions.

Nous sommes maintenant des pros de l’ajout d’AROs et de l’utilisation des techniques de création d’arbres d’ACO. La création de groupes d’un niveau supérieur utilise le model Aco du coeur.

Assigner les Permissions¶

Après la création de nos ACOs et AROs, nous pouvons finalement assigner des permissions entre les deux groupes. Ceci est réalisé en utilisant le component Acl du cœur de CakePHP. Continuons avec notre exemple.

Ici nous travaillerons dans un contexte d’une action de controller. Nous faisons cela parce que les permissions sont managées par le component Acl.

class SomethingsController extends AppController {
    // Vous pourriez placer çà dans AppController
    // mais cela fonctionne bien ici aussi.

    public $components = array('Acl');

}

Configurons quelques permissions de base, en utilisant le Component Acl dans une action à l’intérieur de ce controller.

public function index() {
    //Autorise un accès complet aux armes pour les guerriers
    //Ces exemples utilisent tous deux la syntaxe avec un alias
    $this->Acl->allow('guerriers', 'Armes');

    //Encore que le Roi pourrait ne pas vouloir laisser n'importe qui
    //disposer d'un accès sans limites
    $this->Acl->deny('guerrier/Legolas', 'Armes', 'delete');
    $this->Acl->deny('guerrier/Gimli',   'Armes', 'delete');

    die(print_r('done', 1));
}

Le premier appel que nous faisons au component Acl donne, à tout utilisateur appartenant au groupe ARO “guerriers”, un accès total à tout ce qui appartient au groupe ACO “Armes”. Ici nous adressons simplement les ACOs et AROs d’après leurs alias.

Avez-vous noté l’usage du troisième paramètre? C’est là où nous utilisons ces actions bien pratiques qui sont intégrées à tous les ACOs de CakePHP. Les options par défaut pour ce paramètre sont create, read, update et delete, mais vous pouvez ajouter une colonne dans la table aros_acos de la base de données (préfixée avec _ - par exemple _admin) et l’utiliser en parallèle de celles par défaut.

Le second ensemble d’appels est une tentative d’affiner les permissions. Nous voulons qu’Aragorn conserve ses privilèges de plein accès, mais nous refusons aux autres guerriers du groupe, la capacité de supprimer les enregistrements de la table Armes. Nous utilisons la syntaxe avec un alias pour adresser les AROs ci-dessus, mais vous pourriez utiliser votre propre syntaxe model/clé étrangère. Ce que nous avons ci-dessus est équivalent à ceci :

// 6342 = Legolas
// 1564 = Gimli

$this->Acl->deny(
  array('model' => 'User', 'foreign_key' => 6342),
  'Weapons',
  'delete'
);
$this->Acl->deny(
  array('model' => 'User', 'foreign_key' => 1564),
  'Weapons',
  'delete'
);

La prochaine section nous aidera à valider notre configuration, en utilisant le component Acl pour contrôler les permissions que nous venons de définir.

Vérification des Permissions : le Component ACL¶

Utilisons le Component Acl pour nous assurer que les nains et les elfes ne peuvent déplacer des choses depuis l’armurerie. Maintenant, nous devrions être en mesure d’utiliser le Component Acl, pour faire une vérification entre les ACOs et les AROs que nous avons créés. La syntaxe de base pour faire une vérification des permissions est :

$this->Acl->check($aro, $aco, $action = '*');

Faisons un essai dans une action de controller :

public function index() {
    // Tout cela renvoi true:
    $this->Acl->check('guerriers/Aragorn', 'Armes');
    $this->Acl->check('guerriers/Aragorn', 'Armes', 'create');
    $this->Acl->check('guerriers/Aragorn', 'Armes', 'read');
    $this->Acl->check('guerriers/Aragorn', 'Armes', 'update');
    $this->Acl->check('guerriers/Aragorn', 'Armes', 'delete');


    // Souvenez-vous, nous pouvons utiliser la syntaxe model/clé étrangère
    // pour nos AROs utilisateur
    $this->Acl->check(array('User' => array('id' => 2356)), 'Weapons');

    // Tout cela renvoi true également:
    $result = $this->Acl->check('guerriers/Legolas', 'Armes', 'create');
    $result = $this->Acl->check('guerriers/Gimli', 'Armes', 'read');


    // Mais ceci retourne "false" :
    $result = $this->Acl->check('guerriers/Legolas', 'Armes', 'delete');
    $result = $this->Acl->check('guerriers/Gimli', 'Armes', 'delete');

}

L’usage fait ici est démonstratif, mais vous pouvez sans doute voir comment une telle vérification peut être utilisée, pour décider à quel moment autoriser, ou pas, quelque chose à se produire, pour afficher un message d’erreur ou rediriger l’utilisateur vers un login.