Listes de Contrôle d’Accès (ACL)¶

Pour commencer :¶

L’implémentation par défaut des permissions ACL profite des fonctionnalités offertes par les bases de données. La base de données Cake pour les ACL est composé d’un ensemble de modèles du coeur et d’une console d’application qui sont créés lors de votre installation de Cake. Les Modèles sont utilisés par Cake pour interagir avec la base de données afin de stocker et de retrouver les noeuds de notre implémentation en format d’arbre. La console d’application est quand à elle utilisée pour initialiser votre base de données et pour interagir avec vos arbres d’ACO et d’ARO.

Pour commencer, vous devrez d’abord être sur que votre /app/config/database.php soit 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 dans votre base de données d’ACL :

$ cake schema create DbAcl

Cette commande va supprimer et recréer les tables nécessaires au stockage des informations des ACO et des ARO dans notre implémentation en arbre. La sortie console devrait ressembler à ça :

---------------------------------------------------------------
Shell du schéma de Cake
---------------------------------------------------------------

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.

Ceci remplace une commande désuète et dépréciée, « initdb ».

Vous pouvez aussi vous servir du fichier SQL que vous trouverez dans app/config/sql/db_acl.sql, mais ça 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).

Si vous êtes intéressé par la façon de stocker de Cake dans ces tables, parcourez les tables. Le composant ACL utilise le comportement en arbre pour gérer les héritages. Le fichiers de modèle de classe pour ACL sont compilés dans un seul fichier db_acl.php.

Maintenant que nous avons tout configuré, attelons nous à la création d’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 modèle 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.

Généralement, quand vous créez un groupe ou un objet de niveau supérieur, nous recommandons d’utiliser un alias. Si vous gérez l’accès à un enregistrement ou à un article particulier de la base de données, nous recommandons d’utiliser la méthode du modèle/clé étrangère.

Vous voulez créer de nouveaux objets ACL en utilisant le modèle ACL du coeur de CalePHP. 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 modèle (s’il en est). Par exemple, un certain nombre d’AROs correspondraient aux enregistrement 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 User avec un seul appel find() au modèle 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 modèle.

L”alias d’un objet ACL 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 modèle. 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 et d’inclure les composants ACL de Cake dans votre tableau $composents du contrôleur :

var $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 contrôleur :

Tant que les exemples que nous voyons ici nous montrent la création d’ARO, les mêmes techniques pourront être utilisées pour la création d’un arbre d’ACO.

Pour rester dans notre configuration de Communauté, nous allons d’abord créer nos groups d’ARO. De fait que 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 contrôleur 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 ARIs et des ACOs à la volée.

Ce ne devrait rien avoir de radicalement nouveau - nous sommes justes entrain d’utiliser les modèles pour enregistrer les données comme nous le faisons toujours :

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 consile 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 modèle de notre base de données.

Quand nous ajouterons un noeud enfant à un arbre, nous devrons nous assurer d’utiliser les ID des noeuds ACL, plutôt que d’utiliser la valeur de la foreign_key (clé étrangère).

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 modèle 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 ...
}

Typiquement vous n’aurez pas à fournir et un alias, et un modèle/clé_étrangère, mais nous les utiliserons ici pour faire une structure d’arbre plus facile à lire pour les besoins de la démonstrations.

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. Tant que nous pouvons structurer plus que par une représentation abstraite que celle de nos ACO, il est parfois plus pratique de modéliser un arbre ACO après que la configuration faite par le Contrôleur/Action de Cake. Nous avons cinq principaux objets à manipuler dans le scénario de la Communauté, pour la configuration naturelle de ce dernier dans une application Cake est un groupe de modèles, et enfin pour les contrôleurs qui le manipulent. A côté des contrôleurs eux-mêmes, nous allon vouloir contrôler l’accès à des actions spécifiques de ces contrôleurs.

Basés sur cette idée, nous allons configurer un arbre d’ACO qui va imiter une configuration d’application Cake. 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 fils sous chacun de ces cinq principaux ACOs, mais l’utilisation des actions de management intégrées à Cake 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 comment assigner les permissions.

Nous sommes maintenant des pro 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 modèle 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 composant Acl du cœur de CakePHP. Continuons avec notre exemple.

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

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

    var $components = array('Acl');

}

Configurons quelques permissions de base, en utilisant le Composant Acl dans une action à l’intérieur de ce contrôleur.

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('guerriers/Legolas', 'Armes', 'delete');
    $this->Acl->deny('guerriers/Gimli',   'Armes', 'delete');

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

Le premier appel que nous faisons au composant 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 Cake. 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 de prendre une décision un peu plus précise sur 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 modèle/clé étrangère. Ce que nous avons ci-dessus est équivalent à ceci :

// 6342 = Legolas
// 1564 = Gimli

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

L’adressage d’un nœud en utilisant la syntaxe avec un alias, nécessite une chaîne délimitée par des slashs (“/utilisateurs/salaries/developpeurs”). L’adressage d’un nœud en utilisant la syntaxe modèle/clé étrangère nécessite un tableau avec deux paramètres : array('model' => 'Utilisateur', 'foreign_key' => 8282).

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

Vérification des Permissions : le Composant ACL¶

Utilisons le Composant Acl pour s’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 Composant 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 contrôleur :

function index()
{
    // Tout cela renvoie "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 modèle/clé étrangère
    // pour nos AROs utilisateur
    $this->Acl->check(array('model' => 'User', 'foreign_key' => 2356), 'Armes');

    // Ceci retourne "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.