Authentification d'utilisateurs dans Zend Framework

Introduction à l'authentification

Une fois que l'application a récupéré les informations d'un utilisateur, elle doit vérifier leur "authenticité", c'est l'authentification. Pour celà, deux informations sont nécessaires : l'identifiant et un ensemble de règles régissant cet identifiant, aujourd'hui typiquement une chaine de caractères servant de mot de passe est très classique, mais d'autres procédés existent (reconnaissances digitales, occulaires...)

Un identifiant peut lui aussi être un "login" tout banal, mais pourquoi pas un numéro de membre, une adresse email... le secret, lui, est donc souvent un mot de passe sous forme de chaine de caractères.

Utilisation de base de Zend_Auth

Dans l'exemple suivant, nous utiliserons Zend_Auth afin d'effectuer une authentification des plus classiques: champ login et password puis vérification en base de données. Cet exemple suppose que vous utilisez Zend_Application afin de configurer une connexion à une base de données.

Zend_Auth effectue deux tâches. D'abord elle doit récupérer un adaptateur d'authentification afin de déclencher le processus d'authentification, puis si celui-ci est correct, elle doit faire persister ces informations entre requêtes. Pour assurer cette persistance, Zend_Auth utilise un Zend_Session_Namespace, mais en général vous n'aurez pas besoin d'agir sur cet objet.

Supposant une table de base de données suivante:

  1. CREATE TABLE users (
  2.     id INTEGER  NOT NULL PRIMARY KEY,
  3.     username VARCHAR(50) UNIQUE NOT NULL,
  4.     password VARCHAR(32) NULL,
  5.     password_salt VARCHAR(32) NULL,
  6.     real_name VARCHAR(150) NULL
  7. )

C'est une table qui inclue des champs nom, password et aussi grain de sel. Le grain de sel est utilisé pour améliorer la sécurité contre les attaques par force brute qui cibleraient l'alogithme de hashage du mot de passe. » Plus d'informations sur le grain de sel.

Créons un formulaire de login simple. Nous utiliserons Zend_Form.

  1. // localisé à application/forms/Auth/Login.php
  2.  
  3. class Default_Form_Auth_Login extends Zend_Form
  4. {
  5.     public function init()
  6.     {
  7.         $this->setMethod('post');
  8.  
  9.         $this->addElement(
  10.             'text', 'username', array(
  11.                 'label' => 'Username:',
  12.                 'required' => true,
  13.                 'filters'    => array('StringTrim'),
  14.             ));
  15.  
  16.         $this->addElement('password', 'password', array(
  17.             'label' => 'Password:',
  18.             'required' => true,
  19.             ));
  20.  
  21.         $this->addElement('submit', 'submit', array(
  22.             'ignore'   => true,
  23.             'label'    => 'Login',
  24.             ));
  25.  
  26.     }
  27. }

Ce formulaire nous mène vers la création du contrôleur de traitement. Nous l'appellerons "AuthController", et le logerons dans application/controllers/AuthController.php. Il possèdera une seule méthode " loginAction()" vers laquelle le formulaire enverra, la méthode va donc réagir à GET et à POST, elle encapsule toute la logique.

Le code suivant montre comment construire l'adaptateur d'authentification et l'intégration du formulaire:

  1. class AuthController extends Zend_Controller_Action
  2. {
  3.  
  4.     public function loginAction()
  5.     {
  6.         $db = $this->_getParam('db');
  7.  
  8.         $loginForm = new Default_Form_Auth_Login();
  9.  
  10.         if ($loginForm->isValid($_POST)) {
  11.  
  12.             $adapter = new Zend_Auth_Adapter_DbTable(
  13.                 $db,
  14.                 'users',
  15.                 'username',
  16.                 'password',
  17.                 'MD5(CONCAT(?, password_salt))'
  18.                 );
  19.  
  20.             $adapter->setIdentity($loginForm->getValue('username'));
  21.             $adapter->setCredential($loginForm->getValue('password'));
  22.  
  23.             $auth   = Zend_Auth::getInstance();
  24.             $result = $auth->authenticate($adapter);
  25.  
  26.             if ($result->isValid()) {
  27.                 $this->_helper->FlashMessenger('Successful Login');
  28.                 $this->_redirect('/');
  29.                 return;
  30.             }
  31.  
  32.         }
  33.  
  34.         $this->view->loginForm = $loginForm;
  35.  
  36.     }
  37.  
  38. }

Le script de vue est quant à lui enfantin, il sera logé dans application/views/scripts/auth/login.phtml:

  1. $this->form->setAction($this->url());
  2. echo $this->form;

Et voila! Avec ce scénario de base, vous pouvez étendre les possibilités et répondre à vos besoins précis. Tous les adaptateurs Zend_Auth se trouvent décrits dans le guide de réference.

blog comments powered by Disqus