Documentation

Authentification avec une table de base de données - Zend_Auth

Authentification avec une table de base de données

Introduction

Zend_Auth_Adapter_DbTable fournit la possibilité d'authentifier sur la base de crédits stockés dans une table de base de données. Comme Zend_Auth_Adapter_DbTable requiert qu'une instance de Zend_Db_Adapter_Abstract soit fournie à son constructeur, chaque instance est liée à une connexion de base de données particulière. Les autres options de configuration peuvent être réglées grâce au constructeur ou au travers de différentes méthodes, une pour chaque option.

Les options de configuration disponibles incluent :

  • tableName : il s'agit du nom de la table dans la base de données qui contient les crédits d'authentification, et envers laquelle la requête d'authentification sera réalisée.

  • identityColumn : il s'agit du nom de la colonne dans la table utilisée pour représenter l'identité. La colonne d'identité doit contenir une valeur unique, comme un "username" ou une adresse émail.

  • credentialColumn : il s'agit du nom de la colonne dans la table utilisée pour représenter le crédit. Dans le cas d'une simple authentification par identité / mot de passe, la valeur de crédit correspond au mot de passe. Voir aussi l'option credentialTreatment.

  • credentialTreatment : dans la plupart des cas, les mots de passe et autres données sensibles sont cryptés, hachés, encodés, masqués, ou sinon traités à travers une fonction ou un algorithme. En spécifiant un traitement paramétrable de chaîne avec cette méthode, comme MD5(?) ou PASSWORD(?), un développeur peut appliquer un code SQL arbitraire sur les données de crédit fournies. Comme ces fonctions sont spécifiques à chaque gestionnaire de base de données (SGBD), vérifiez le manuel de la base de données pour vérifier la disponibilité de ces fonctions dans votre système.

Example #1 Utilisation basique

Comme expliqué dans l'introduction, le constructeur de Zend_Auth_Adapter_DbTable requiert une instance de Zend_Db_Adapter_Abstract qui est utilisée comme connexion à la base de données à laquelle l'instance d'adaptateur d'authentification est liée. Avant tout, la connexion à la base de donnée devrait être crée.

Le code suivant crée un adaptateur pour une base de données en mémoire, crée un schéma avec une table unique, et insère une ligne sur laquelle nous pouvons réaliser une requête d'authentification plus tard. Cet exemple requiert que l'extension PDO SQLite soit disponible :

  1. // Crée une connexion de base de données SQLite en mémoire
  2. $dbAdapter = new Zend_Db_Adapter_Pdo_Sqlite(array('dbname' =>
  3.                                                   ':memory:'));
  4.  
  5. // Construit une requête de création de table
  6. $sqlCreate = 'CREATE TABLE [users] ( '
  7.            . '[id] INTEGER  NOT NULL PRIMARY KEY, '
  8.            . '[username] VARCHAR(50) UNIQUE NOT NULL, '
  9.            . '[password] VARCHAR(32) NULL, '
  10.            . '[real_name] VARCHAR(150) NULL)';
  11.  
  12. // Crée la table de crédits d'authentification
  13. $dbAdapter->query($sqlCreate);
  14.  
  15. // Construit la requête pour insérer une ligne pour laquelle
  16. // l'authentification pourra réussir
  17. $sqlInsert = "INSERT INTO users (username, password, real_name) "
  18.            . "VALUES ('my_username', 'my_password', 'My Real Name')";
  19.  
  20. // Insertion des données
  21. $dbAdapter->query($sqlInsert);

Avec une connexion de base de données et des données disponibles dans la table, une instance de Zend_Auth_Adapter_DbTable peut être créée. Les valeurs d'options de configuration peuvent être fournies au constructeur ou en tant que paramètres aux méthodes de réglage après l'instanciation :

  1. // Configure une instance avec des paramètres de constructeur ...
  2. $authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter,
  3.                                              'users',
  4.                                              'username',
  5.                                              'password');
  6.  
  7. // ... ou configure l'instance avec des méthodes de réglage
  8. $authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter);
  9. $authAdapter->setTableName('users')
  10.             ->setIdentityColumn('username')
  11.             ->setCredentialColumn('password');

A cet instant, l'instance de l'adaptateur d'authentification est prête à recevoir des requêtes d'authentification. Dans le but de réaliser une requête d'authentification, les valeurs des crédits requêtés sont fournies à l'adaptateur avant d'appeler la méthode authenticate() :

  1. // Règle les valeurs d'entrées des crédits
  2. // (en général, à partir d'un formulaire d'enregistrement)
  3. $authAdapter->setIdentity('my_username')
  4.             ->setCredential('my_password');
  5.  
  6. // Réalise la requête d'authentification, et sauvegarde le résultat
  7. $result = $authAdapter->authenticate();

En plus de la disponibilité de la méthode getIdentity() pour récupérer l'objet du résultat d'authentification, Zend_Auth_Adapter_DbTable supporte aussi la récupération de la ligne de la table qui a réussi l'authentification :

  1. // Affiche l'identité
  2. echo $result->getIdentity() . "\n\n";
  3.  
  4. // Affiche la ligne de résultat
  5. print_r($authAdapter->getResultRowObject());
  6.  
  7. /* Affiche:
  8. my_username
  9.  
  10. Array
  11. (
  12.     [id] => 1
  13.     [username] => my_username
  14.     [password] => my_password
  15.     [real_name] => My Real Name
  16. )
  17. */

Puisque la ligne de la table contient la valeur de crédit, il est important de garantir ces valeurs contre l'accès fortuit.

Utilisation avancée : maintenir persistant l'objet de résultat DbTable

Par défaut, Zend_Auth_Adapter_DbTable retourne l'identité fournie à l'objet Auth en cas d'authentification couronnée de succès. Un autre scénario d'utilisation, où les développeurs veulent stocker dans le mécanisme de stockage persistant du Zend_Auth un objet d'identité contenant d'autres informations utiles, est résolu en utilisant la méthode getResultRowObject() retournant un objet stdClass. Le petit bout de code suivant illustre cette utilisation :

  1. // authentifie avec Zend_Auth_Adapter_DbTable
  2. $result = $this->_auth->authenticate($adapter);
  3.  
  4. if ($result->isValid()) {
  5.  
  6.     // stocke l'identité comme objet dans lequel seulement username et
  7.     // real_name sont retournés
  8.     $storage = $this->_auth->getStorage();
  9.     $storage->write($adapter->getResultRowObject(array('username',
  10.                                                        'real_name')));
  11.  
  12.     // stocke l'identité comme objet dans lequel la colonne password
  13.     // a été omis
  14.     $storage->write($adapter->getResultRowObject(null, 'password'));
  15.  
  16.     /* ... */
  17.  
  18. } else {
  19.  
  20.     /* ... */
  21.  
  22. }

Utilisation avancée par l'exemple

Bien que le but initial de Zend_Auth (et par extension celui de Zend_Auth_Adapter_DbTable) est principalement l'authentification et non l'autorisation (ou contrôle d'accès), il existe quelques exemples et problèmes qui franchissent la limite des domaines auxquels ils appartiennent. Selon la façon dont vous avez décidé d'expliquer votre problème, il semble parfois raisonnable de résoudre ce qui pourrait ressembler à un problème d'autorisation dans l'adaptateur d'authentification.

Ceci étant dit, Zend_Auth_Adapter_DbTable possède des mécanismes qui sont construits de telle sorte qu'ils peuvent être démultipliés pour ajouter des contrôles supplémentaires au moment de l'authentification pour résoudre quelques problèmes communs d'utilisateur.

  1. // La valeur du champs "etat" d'un compte
  2. // ne doit pas être égal à "compromis"
  3. $adapter = new Zend_Auth_Adapter_DbTable($db,
  4.                                          'utilisateurs',
  5.                                          'login',
  6.                                          'password',
  7.                                          'MD5(?) AND etat != "compromis"');
  8.  
  9. // La valeur du champs "actif" d'un compte
  10. // doit être égal à "TRUE"
  11. $adapter = new Zend_Auth_Adapter_DbTable($db,
  12.                                          'utilisateurs',
  13.                                          'login',
  14.                                          'password',
  15.                                          'MD5(?) AND actif = "TRUE"');

Un autre scénario possible est l'implantation d'un mécanisme de "salting". "Salting" est un terme se référant une technique qui peut fortement améliorer la sécurité de votre application. C'est basé sur l'idée que concaténer une chaîne aléatoire à tout mot de passe rend impossible la réussite d'une attaque de type "brute force" sur la base de données en utilisant des valeurs préalablement hashées issues d'un dictionnaire.

Par conséquent nous devons modifier notre table pour stocker notre chaîne de "salt" aléatoire :

  1. $sqlAlter = "ALTER TABLE [users] "
  2.           . "ADD COLUMN [password_salt] "
  3.           . "AFTER [password]";
  4.  
  5. $dbAdapter->query($sqlAlter);

Voici une méthode simple pour générer une chaîne aléatoire pour chaque utilisateur à leur enregistrement :

  1. for ($i = 0; $i < 50; $i++)
  2. {
  3.     $dynamicSalt .= chr(rand(33, 126));
  4. }

Et maintenant, construisons l'adaptateur :

  1. $adapter = new Zend_Auth_Adapter_DbTable(
  2.     $db,
  3.     'users',
  4.     'username',
  5.     'password',
  6.     "MD5(CONCAT('"
  7.     . Zend_Registry::get('staticSalt')
  8.     . "', ?, password_salt))"
  9. );

Note: Vous pouvez encore améliorer la sécurité en utilisant une chaîne de "salt" statique codée en dur dans votre application. Dans le cas ou la base de données est compromise (par exemple par une attaque de type injection SQL) mais que votre serveur Web est intact, les données sont inutilisables par l'attaquant.

Une autre alternative est d'utiliser la méthode getDbSelect() de la classe Zend_Auth_Adapter_DbTable après la construction de l'adaptateur. Cette méthode retournera une instance d'objet Zend_Db_Select utilisée pour réaliser la routine authenticate(). Il est important de noter que cette méthode retournera toujours le même objet, que la méthode authenticate() a été appelée ou non. Cet objet ne comportera aucune information d'identité ou de crédit puisque celles-ci sont placées dans l'objet select au moment de authenticate().

Un exemple de situation nécessitant l'utilisation de la méthode getDbSelect() serait de vérifier le statut d'un utilisateur, en d'autres termes pour voir si le compte d'un utilisateur est activé.

  1. // En continuant avec l'exemple ci-dessus
  2. $adapter = new Zend_Auth_Adapter_DbTable(
  3.     $db,
  4.     'users',
  5.     'username',
  6.     'password',
  7.     'MD5(?)'
  8. );
  9.  
  10. // Récupérer l'objet select (par référence)
  11. $select = $adapter->getDbSelect();
  12. $select->where('active = "TRUE"');
  13.  
  14. // Authentification, ceci s'assure que users.active = TRUE
  15. $adapter->authenticate();

Copyright

© 2006-2022 by Zend by Perforce. Made with by awesome contributors.

This website is built using zend-expressive and it runs on PHP 7.

Contacts