Lista de Controle de Acesso¶

Começando¶

O padrão da implementação de permissões ACL é em base de dados. A base de dados ACL do Cake consiste de um conjunto de modelos, e uma aplicação console que vem com a instalação do Cake. Os modelos são usados pelo Cake para intergir com a base de dados para armazenar e recuperar nós em formato de árvore. A aplicação console é usada para inicializar sua base de dados e interagir com suas árvores ACO e ARO.

Para começar, você precisa primeiro ter certeza que o arquivo /app/config/database.php está presente e configurado corretamente. Veja a seção 4.1 para maiores informações sobre a configuração da base de dados.

Mesmo que você tenha finalizado, use o console CakePHP para criar suas tabelas da base de dados ACL:

$ cake schema run create DbAcl

Rodando esse comando, ele irá apagar e re-criar as tabelas necessárias para armazenar as informações em formato de árvore de ACO e ARO. A saída da aplicação console deveria ser como a seguir:

---------------------------------------------------------------
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.

Isso substitui um comando depreciado, «initdb».

Você pode mesmo usar o arquivo SQL que pode ser encontrado em app/config/sql/db_acl.sql, mas isso não tem muita graça.

Quando terminado, você deveria ter três novas tabelas na sua base de dados do seu sistema: acos, aros e aros_acos (uma junção das tabelas para criar informações de permissões entre as duas árvores).

Se você está curioso sobre como o Cake armazena as informações em àrvore nessas tabelas, leia sobre modificação transversal em base de dados em formato de árvore. O componente ACL usa o Behavior Tree do Cake para gerenciar as heranças das árvores. Os arquivos de modelo de classes para ACL estão todos compilados em um único arquivo db_acl.php.

Agora que você está sabendo tudo, vamos começar a trabalhar criando algumas árvores ARO e ACO.

Criado Acesso de Requisição de Objetos (AROs) e Controle de Acesso a Objetos (ACOs)¶

Criando nos objetos ACL (ACOs e AROs), verifique que existem duas formas principais de nomear e chamar nodes. A primeira forma é linkar o objeto diretamente ao registro na sua base de dados, especificando um nome de molde e um valor de chave estrangeira. A segunda forma pode ser usada quando um objeto não tem uma relação direta com o registro em sua base de dados - você pode fornecer um álias para o objeto.

Comumente, quando você está criando um grupo ou objeto de nível alto, use um álias. Se você está gerenciando acesso para um item específico ou registro na base de dados, use a forma modelo/chave estrangeira.

Você cria novos objetos ACL usando o núcleo ACL do CakePHP. Fazendo isso, existem um número de campos que você precisará usar quando estiver salvando dados: model, foreign_key, alias, e parent_id.

Os campos model e foreign_key para um objeto ACL permite que você ligue o objeto para o seu modelo correspondente ao registro (se existir algum). Por exemplo, muitos AROs terão registros User correpondentes na base de dados. Setando um ARO foreign_key para o User ID irá permitir você ligar ARO e informações User com um simples modelo User find() chamado se você tiver setado corretamente as associações de modelo. Inversamente, se você quer gerenciar operações de edição em um post de blog específico ou listar receitas, você pode escolher ligar um ACO a um registro específico de modelo.

O álias para um objeto ACL é apenas um rótulo que você pode usar para identificar um objeto ACL que não tem correlação de registro modelo direta. Álias são geralmente úteis nomeando grupo de usuários ou coleções de ACO.

O parent_id para um objeto ACL permite você preencher a estrutura da árvore. Forneça o ID do node filho na árvore para criar um novo filho.

Antes nós podemos criar novos objeto ACL, nós precisamos carregar essas respectivas classes. A forma mais fácil para fazer isso é incluir o componente ACL no seu array controladora $components array:

var $components = array('Acl');

Depois de feito isso, vamos ver o que alguns desses exemplos de criação de objetos se parecem. O código a seguir pode ser colocado em qualquer lugar na action:

Enquanto os exemplos aqui focam a criação de ARO, as mesmas técnicas podem ser usadas para criar uma árvore ACO.

Mantendo com a nossa configuração de Sociedade, vamos primeiro criar nossos grupos ARO. Porque nossos grupos não têm registros específicos vinculados a eles, nós iremos usar álias para criar esses objetos ACL. O que nós temos que fazer aqui é a partir da perspectiva da action da controladora, mas pode ser feito em outro lugar. O que nós vamos cobrir aqui é um pedaço da abordagem artificial, mas você deve se sentir confortável para usar estas técnicas para construir AROs e ACOs em situções reais.

Isso não deve ser algo drasticamente novo - nós estamos apenas usando modelos para salvar dados como nós sempre fazemos:

function anyAction()
{
    $aro =& $this->Acl->Aro;

    //Aqui estão todas informações sobre nosso grupo num array
    $groups = array(
        0 => array(
            'alias' => 'warriors'
        ),
        1 => array(
            'alias' => 'wizards'
        ),
        2 => array(
            'alias' => 'hobbits'
        ),
        3 => array(
            'alias' => 'visitors'
        ),
    );

    //Iterar e criar grupos ARO
    foreach($groups as $data)
    {
        //Lembre-se de chamar create() quando salvar em loops...
        $aro->create();

        //Save data
        $aro->save($data);
    }

    //Outras lógicas da action vão aqui...
}

Uma vez que nós temos eles lá dentro, podemos usar a aplicação de console do ACL para verificar a estrutura da árvore.

$ cake acl view aro

Aro tree:
---------------------------------------------------------------
  [1]warriors

  [2]wizards

  [3]hobbits

  [4]visitors

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

Eu suponho que não é muito de uma árvore esse ponto, mas pelo menos temos alguma verificação que nós temos para os quatros principais níveis. Vamos adicionar alguns filhos para esse node ARO, adicionando seus usuários AROs específicos, debaixo desses grupos. Todos bons cidadãos de Middle Earth tem uma conta no nosso sistema, então nós iremos amarrar esses registros ARO para um modelo específico de registros na nossa base de dados.

Quando adicionar nodes filhos para uma árvore, tenha certeza de usar o node ID do ACL, invés de um valor foreign_key.

function anyAction()
{
    $aro =new Aro();

        // Aqui são seus registros de usuário, lidos para serem ligados para os novos
        // registros ARO.
        // Esses dados devem vir do modelo e modificado, mas nós estamos usando estáticos
        // arrays aqui apenas para demostração

    $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,
        ),
    );

    //Itera e cria AROs (como filhos)
    foreach($users as $data)
    {
        //Lembre-se de chamar o create() quando estiver salvando em loops...
        $aro->create();

        //Salvar os dados
        $aro->save($data);
    }

    //Outras lógicas da action vão aqui...
}

Tipicamente você não pode fornecer álias e um modelo/chave estrangeira, mas nós estamos usando ambos aqui para fazer a estrutura de árvore mais fácil para ler, mas apenas como demonstração.

A saída da aplicação de console deve ser agora um pouco mais interessante. Vamos ver a possibilidade:

$ cake acl view aro

Aro tree:
---------------------------------------------------------------
  [1]warriors

    [5]Aragorn

    [6]Legolas

    [7]Gimli

  [2]wizards

    [8]Gandalf

  [3]hobbits

    [9]Frodo

    [10]Bilbo

    [11]Merry

    [12]Pippin

  [4]visitors

    [13]Gollum

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

Agora que nós tempos nossa árvore ARO contruída corretamente, vamos discutir uma possível abordagem para estruturar uma árvore ACO. Embora possamos estruturar mais de uma representação abstrata de nossa ACO, é muitas vezes mais prático modelar uma árvore ACO depois de configurar as Controladoras/Action do Cake. Nós temos cinco objetos principais que temos de controlar em nosso cenário de Sociedade, e a configuração natural para que em uma aplicação Cake está um grupo de modelos, e finalmente os controladores que os manipulam. Passado os controladores, nós vamos querer controlar acesso a actions específicas naquelas controladoras.

Com base nessa idéia, vamos configurar uma árvore ACo que irá imitar o setup de uma aplicação Cake. Pois temos cinco ACOs, nós iremos criar uma árvore ACO que deve acabar procurando algo como a seguir:

• Weapons

• Rings

• PorkChops

• DiplomaticEfforts

• Ales

Um detalhe legal sobre a configuração do ACL do Cake é que cada ACO contém automaticamente quatro propriedades relacionadas a actions CRUD (criar, pesquisar, atualizar e deletar). Você pode criar nodes filhos abaixo de cada um desses cinco principais ACOs, mas usando o construtor de gerenciamento de actions do Cake que abrange as operações básicas do CRUD sobre um determinado objeto.

Uma vez que você está agora adicionando AROs, use aquelas mesmas técnicas para criar essa árvore ACO. Criar esses níveis de grupos usando o modelo ACO.

Atribuindo Permissões¶

Depois de criar seus ACOs e AROs, nós podemos finalmente atribuir permissões entre os dois grupos. Esse é feito usando o núcleo do componente ACL. Vamos continuar com nosso exemplo.

Aqui nós iremos trabalhar no contexto da action da controladora. Nós faremos porque as permissões são gerenciadas pelo componente ACL.

class SomethingsController extends AppController
{
    // Você pode querer colocar isso no AppController
    // mas aqui funciona muito bem também

    var $components = array('Acl');

}

Vamos confugurar algumas permissões básicas usando o componente AclComponent na action dentro dessa controladora.

function index()
{
        // Permite guerreiros (warriors) a acesso completa a armas (weapons)
        // Ambos exemplos usam a sintaxe de álias
    $this->Acl->allow('warriors', 'Weapons');

        // Embora o rei não possa querer todos
        // tem acesso ilimitado
    $this->Acl->deny('warriors/Legolas', 'Weapons', 'delete');
    $this->Acl->deny('warriors/Gimli',   'Weapons', 'delete');

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

A primeiro conjuneto de chamadas nós fazemos para o AclComponent permir que qualquer usuário abaixo do grupo ARO “warriors” tenha acesso completo a qualquer coisa abaixo do grupo ACO “Weapons”. Aqui estamos apenas abordando os ACOs e AROs pelo seus álias.

Observou o uso do terceiro parâmetro? Isso é onde nós usamos aqueles controles que estão dentro de todos ACO Cake. A opção padrão para que os parâmetros são create, read, update, e delete mas você pode adicionar uma coluna na tabela aros_acos (prefixado com _ - por exemplo _admin) e usá-lo juntamente com os padrões.

O segundo conjunto de chamadas é uma tentativa de fazer decisão de permissão de granularidade alta. Nós queremos que Aragorn mantenha seu privilégio de acesso, mas recusar que outros guerreiros do grupo tenha permissão para deletar registros de armas. Nós estamos usando álias para resolver o AROs acima, mas você pode querer usar a sintaxe modelo/chave estrangeira. O que nós temos acima é equivalente a isso:

// 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');

Endereçando um node usando a sintaxe álias usa o delimitador “/” (“/users/employees/developers”). Endereçando um node usando a sintaxe modelo/chave estrangeira usa um array com dois parâmetros: array('model' => 'User', 'foreign_key' => 8282).

A próxima seção irá nos ajudar a validar nossa configuração usando o AclComponent para checar as permissões que acabamos de criar.

Checando Permissões: O Componente ACL¶

Vamos usar o AclComponent para ter certeza que dwarves e elves não podem remover coisas do depósito de armas. Nesse ponto, deveríamos ser capazes de utilizar o AlcComponent para fazer a verificação entre os ACOs e AROs que criamos. O comando básico para fazer a verificação das permissões é:

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

Vamos tentar dar-lhe uma action dentro da controladora:

function index()
{
    //Isso tudo retorna true:
    $this->Acl->check('warriors/Aragorn', 'Weapons');
    $this->Acl->check('warriors/Aragorn', 'Weapons', 'create');
    $this->Acl->check('warriors/Aragorn', 'Weapons', 'read');
    $this->Acl->check('warriors/Aragorn', 'Weapons', 'update');
    $this->Acl->check('warriors/Aragorn', 'Weapons', 'delete');

    //Lembre-se, nós podemos usar a sintaxe model/foreign key
    //para nossos usuários AROs
    $this->Acl->check(array('model' => 'User', 'foreign_key' => 2356), 'Weapons');

    //Isso também vai retornar true:
    $result = $this->Acl->check('warriors/Legolas', 'Weapons', 'create');
    $result = $this->Acl->check('warriors/Gimli', 'Weapons', 'read');

    //Mas isso retorna false:
    $result = $this->Acl->check('warriors/Legolas', 'Weapons', 'delete');
    $result = $this->Acl->check('warriors/Gimli', 'Weapons', 'delete');
}

O uso aqui é demonstração, mas espero que você pode ver como é verificar como esta pode ser utilizada para decidir se quer ou não permitir que aconteça alguma coisa, mostrar uma mensagem de erro, ou redirecionar o usuário para um login