Welcome to the Cookbook

Les systèmes d'authentification constituent une partie courante de nombreuses applications Web. Avec CakePHP, il y a plusieurs systèmes pour authentifier un utilisateur, chacun fournissant des options différentes. Au coeur du composant d'authentification, on vérifie si l'utilisateur possède un compte sur le site. Si c'est la cas, le composant donne l'accès à tout le site à l'utilisateur. Ce composant peut être combiné avec le composant ACL (access control lists) pour créer des niveaux d'accès à l'intérieur du site. Cela permettra à un utilisateur de s'authentifier comme utilisateur générique tandis qu'un autre sera authentifié comme administrateur qui possède des droits pour accéder aux parties protégées du site.

Le composant AuthComponent peut servir à créer un tel système rapidement et facilement. Regardons comment construire un système d'authentification simple.

Comme n'importe quel composants, vous devrez l'ajouter à la liste des composants en ajoutant 'Auth' dans votre contrôleur :

class FooController extends AppController {
    var $components = array('Auth');

1. class FooController extends AppController {
2. var $components = array('Auth');

Ou ajoutez-le à votre AppController pour le rendre disponible à l'ensemble des contrôleurs :

class AppController extends Controller {
    var $components = array('Auth');

1. class AppController extends Controller {
2. var $components = array('Auth');

Maintenant, il y a quelques conventions auxquelles penser quand on utilise le composant AuthComponent. Par défaut, AuthComponent s'attend à ce que la table des utilisateurs s'appelle 'users' et qu'elle comporte les champs nommées 'username' et 'password'.

Le script SQL suivant met en place une telle table :

CREATE TABLE users (
    id integer auto_increment,
    username char(50),
    password char(50),
    PRIMARY KEY (id)
);

1. CREATE TABLE users (
2. id integer auto_increment,
3. username char(50),
4. password char(50),
5. PRIMARY KEY (id)
6. );

Pour une sécurité accrue, le composant AuthComponent hashe automatiquement les données soumises de n'importe quel formulaire dont le nom correspond au nom du champ que vous avez rattaché au champ password de AuthComponent. Par exemple, si vous avez créé un nouvel utilisateur, la valeur stockée dans $data['User']['password'] sera une valeur hashée plutôt que la chaîne de caractère saisie par l'utilisateur à l'origine.

Ce comportement peut créer quelques difficultés si vous chercher à vous assurer que que le nouvel utilisateur a choisi un mot de passe suffisamment complexe. Par exemple, vous pourriez vous assurer que tous les gens ont des mots de passe de 8 caractères au moins.

Vous pouvez contourner la difficulté en créant un champ dans votre formulaire, dont le nom ne correspond pas au nom du champ mot de passe dans le modèle. Vous pouvez alors valider l'entrée de l'utilisateur, hasher ce champ manuellement et le sauvegarder en base en utilisant le modèle User.

Ce procédé de hashage automatique de mot de passe doit être gardé à l'esprit quand on crée une table pour stocker l'authentification de l'utilisateur. Assurez-vous que le champ mot de passe est suffisamment long pour stocker le hash (40 caractères pour SHA1 par exemple).

Pour le paramétrage le plus basique, il vous faudra créer deux actions dans votre contrôleur :

class UsersController extends AppController {

    var $name = 'Users';    

    function login() {
    }

    function logout() {
        $this->redirect($this->Auth->logout());
    }
}

1. class UsersController extends AppController {
2. var $name = 'Users';
3. function login() {
4. }
5. function logout() {
6. $this->redirect($this->Auth->logout());
7. }
8. }

Vous n'avez réellement besoin que de créer une vue, la page de login (située dans app/views/users/login.ctp). L'exemple ci-dessous présuppose que vous utilisez le Helper Form

<?php
    if  ($session->check('Message.auth')) $session->flash('auth');
    echo $form->create('User', array('action' => 'login'));
    echo $form->input('username');
    echo $form->input('password');
    echo $form->end('Login');
?>

1. <?php
2. if ($session->check('Message.auth')) $session->flash('auth');
3. echo $form->create('User', array('action' => 'login'));
4. echo $form->input('username');
5. echo $form->input('password');
6. echo $form->end('Login');
7. ?>

Cette vue crée un formulaire d'authentification où on peut entrer son nom d'utilisateur et un mot de passe. Quand on soumet le formulaire, le composant AuthComponent prend en charge le reste pour vous. Le message de session flash affichera les messages généré par AuthComponent.

Si vous n'utilisez pas $form->create, assurez-vous que vous éléments input adressent bien les champs en tant que User.username et User.password.

Croyez le ou no, on en a terminé ! Voici comment écrire un système d'authentification fondé sur la base de données avec le composant AuthComponent. Cependant, il y a encore plus de choses qu'on peut faire. Intéressons-nous maintenant à quelques usages avancés du composant.

A chaque fois que vous voulez modifier une option par défaut du composant, vous pouvez le faire en créant une méthode beforeFilter() pour votre contrôleur et en appelant les diverses méthodes natives et les variables de paramétrage du composant.

class UsersController extends AppController {
    var $component = array('Auth');

    function beforeFilter() {
        ....
    }
}

1. class UsersController extends AppController {
2. var $component = array('Auth');
3. function beforeFilter() {
4. ....
5. }
6. }

La touche finale est de faire en sorte que votre layout (gabarit) récupère les messages d'erreur en provenance du composant. Voici ce que ça donne si on les regroupe avec les messages flash ordinaires :

<?php
	if ($session->check('Message.flash')) {
		$session->flash();
	}
	if ($session->check('Message.auth')) {
		$session->flash('auth');
	}
?>

1. <?php
2. if ($session->check('Message.flash')) {
3. $session->flash();
4. }
5. if ($session->check('Message.auth')) {
6. $session->flash('auth');
7. }
8. ?>

Attardons nous maintenant sur les méthodes du composant AuthComponent à notre disposition.