Previous Next

Introduction

Zend_Auth fournit une API pour l'authentification et inclut des adaptateurs concrets d'authentification pour les cas les plus courants.

Zend_Auth est uniquement concerné par le processus d'authentification et non pas par le processus d'autorisation. L'authentification est définie de manière lâche (souple) afin de déterminer si une entité donnée est bien celle qu'elle prétend être (c.-à-d. identification), sur la base d'identifiants fournis. L'autorisation, l'action de décider si une entité donnée peut accéder à d'autres entités et/ou exécuter des opérations sur celles-ci ne fait pas partie des prérogatives de Zend_Auth. Pour plus d'informations sur les autorisations et le contrôle d'accès via le Zend Framework, voyez Zend_Acl.

Note:

La classe Zend_Auth inclut un singleton - uniquement une instance de la classe est disponible - à travers la méthode statique getInstance(). Celle ci utilise un opérateur new et le mot-clé clone ne fonctionnera pas avec la classe Zend_Auth, utilisez getInstance() à la place.

Adaptateurs

Un adaptateur Zend_Auth est utilisé pour authentifier via un service particulier d'authentification, comme LDAP, RDBMS ou un stockage basé sur des fichiers. Les différents adaptateurs peuvent posséder des options et des comportements très divers. Cependant, quelques méthodes de base leur sont communes. Par exemple, accepter des éléments d'authentification (incluant une identité prétendue), authentifier et retourner un résultat sont des éléments communs aux adaptateurs Zend_Auth.

Chaque classe d'adaptateur Zend_Auth implémente Zend_Auth_Adapter_Interface. Cette interface définit une méthode, authenticate, celle-ci est implémentée par une classe adaptateur à fin de réaliser l'authentification. Chaque classe adaptateur doit être préparée avant tout appel de authenticate(). Cela implique que chaque adaptateur fournisse la possibilité de définir des éléments d'authentification (par exemple identifiant et mot de passe) et de définir des valeurs pour les options spécifiques de l'adaptateur, tels que les paramètres de connexion à une base de données pour un adaptateur qui en fait usage.

L'exemple suivant est un adaptateur d'authentification qui requiert un identifiant et un mot de passe. D'autres détails, tel que la manière d'interroger le service d'authentification, ont été omis par souci de clarté :

class MonAdaptateurAuth implements Zend_Auth_Adapter_Interface
{
    /**
     * Définition de l'identifiant et du mot de passe
     * pour authentification
     *
     * @return void
     */
    public function __construct($identifiant, $motdepasse)
    {
        // ...
    }

    /**
     * Réalise une tentative d'authentification
     *
     * @throws Zend_Auth_Adapter_Exception Si l'authentification
     *                                     ne peut pas être réalisée
     * @return Zend_Auth_Result
     */
    public function authenticate()
    {
        // ...
    }
}
Comme indiqué dans la documentation "docblock", authenticate() doit retourner une instance de Zend_Auth_Result (ou d'une classe dérivée de Zend_Auth_Result). Si pour quelque raison que ce soit, la requête d'authentification ne peut pas être réalisée, authenticate() retournera une exception dérivée de Zend_Auth_Adapter_Exception.

Résultats

Les adaptateurs Zend_Auth retournent une instance de Zend_Auth_Result via authenticate() de manière à présenter les résultats d'une tentative d'authentification. Les adaptateurs alimentent l'objet Zend_Auth_Result lors de sa construction, de manière à ce que les quatre méthodes suivantes fournissent de base un lot d'opérations communes aux résultats des adaptateurs Zend_Auth :

  • isValid() : retourne true si et seulement si le résultat représente une tentative réussie d'authentification

  • getCode() : retourne une constante Zend_Auth_Result qui détermine le type de retour accepté ou refusé (NDT : voir tableau ci dessous). Cela peut être utilisé pour les développeurs voulant distinguer en amont les différents types de résultat. Il est possible d'avoir des statistiques détaillées, par exemple. Une autre utilisation est la personnalisation du message de retour au client. Attention cependant à ne pas trop donner de détails aux clients pour des raisons de sécurité. Pour plus de détails, consultez les notes ci-dessous.

  • getIdentity() : retourne l'identité de la tentative d'authentification.

  • getMessages() : retourne un tableau de messages relatifs à une tentative infructueuse d'authentification.

Un développeur peut connecter le résultat de l'authentification avec des opérations spécifiques. Certaines opérations développées peuvent bloquer le compte après plusieurs refus du mot de passe, bannir une adresse IP après plusieurs essais sur des comptes inexistants ou fournir un message spécifique à l'utilisateur final. Les codes suivants sont disponibles :

Zend_Auth_Result::SUCCESS
Zend_Auth_Result::FAILURE
Zend_Auth_Result::FAILURE_IDENTITY_NOT_FOUND
Zend_Auth_Result::FAILURE_IDENTITY_AMBIGUOUS
Zend_Auth_Result::FAILURE_CREDENTIAL_INVALID
Zend_Auth_Result::FAILURE_UNCATEGORIZED

L'exemple suivant illustre comment utiliser le retour :

// A l'intérieur de la méthode AuthController / loginAction
$resultat = $this->_auth->authenticate($adapter);

switch ($resultat->getCode()) {

    case Zend_Auth_Result::FAILURE_IDENTITY_NOT_FOUND:
        /** l'identifiant n'existe pas **/
        break;

    case Zend_Auth_Result::FAILURE_CREDENTIAL_INVALID:
        /** mauvaise authentification **/
        break;

    case Zend_Auth_Result::SUCCESS:
        /** authentification acceptée **/
        break;

    default:
        /** autres cas **/
        break;
}

Persistance d'identité

Authentifier une requête qui contient des paramètres d'authentification est utile en soi, mais il est également important de permettre le maintien de l'identité authentifiée sans avoir à représenter ces paramètres d'authentification à chaque requête.

HTTP est un protocole sans état, cependant, des techniques telles que les cookies ou les sessions ont été développées de manière à faciliter le maintien d'un contexte lors de multiples requêtes dans les applications Web.

Persistance par défaut dans une session PHP

Zend_Session est utilisé par Zend_Auth pour fournir un stockage persistant de l'identité, après une authentification réussie, via les sessions PHP. Après une authentification réussie, Zend_Auth::authenticate() conserve l'identité résultant de l'authentification dans un stockage persistant. Par défaut, Zend_Auth utilise une classe de stockage basée sur Zend_Session. La classe de stockage peut être changée en fournissant un objet de stockage différent à Zend_Auth::setStorage(). Une classe personnalisée peut fournir une implémentation de l'objet Zend_Auth_Storage_Interface à Zend_Auth::setStorage().

Note:

Si la persistance automatique de l'identité n'est pas souhaitable dans un cas particulier, alors le développeur peut renoncer à utiliser la classe Zend_Auth et préférer utiliser directement une classe adaptateur.

Example #1 Changer l'espace de nommage de la session

Zend_Auth_Storage_Session utilise un espace de nommage de "Zend_Auth". Cet espace peut être écrit en passant les valeurs au constructeur de Zend_Auth_Storage_Session, et ces valeurs sont passées en interne au constructeur de Zend_Session_Namespace. Cela doit être fait avant l'authentification, et avant que Zend_Auth::authenticate() ait accompli le stockage automatique de l'identité.

// Sauver une référence du singleton, instance de Zend_Auth
$auth = Zend_Auth::getInstance();

// Utiliser 'unEspaceDeNommage' instance de 'Zend_Auth'
$auth->setStorage(new Zend_Auth_Storage_Session('unEspaceDeNommage'));

/**
 * @todo Paramètrage de l'adaptateur d'authentification :
 *       $authAdaptateur
 */

// authentification, sauvegarde du résultat
// et stockage du résultat en cas de succès
$resultat = $auth->authenticate($authAdaptateur);

Installer un stockage personnalisé

Parfois les développeurs ont besoin d'utiliser un comportement de persistance d'identité différent de celui fourni par Zend_Auth_Storage_Session. Dans ces cas, les développeurs implémentent simplement Zend_Auth_Storage_Interface et fournissent t une instance de la classe à Zend_Auth::setStorage().

Example #2 Utiliser une classe de stockage personnalisée

Pour utiliser une classe de stockage d'identité persistante autre que Zend_Auth_Storage_Session, le développeur commence par implémenter Zend_Auth_Storage_Interface:

class MonStockage implements Zend_Auth_Storage_Interface
{
    /**
     * Retourne true si et seulement si le stockage est vide
     *
     * @throws Zend_Auth_Storage_Exception S'il est impossible de déterminer
     *                                     si le stockage est vide
     * @return boolean
     */
    public function isEmpty()
    {
        /**
         * @todo implémentation
         */
    }

    /**
     * Retourne le contenu du stockage
     *
     * Comportement à définir si le stockage est vide.
     *
     * @throws Zend_Auth_Storage_Exception Si la lecture du stockage
     *                                     est impossible
     * @return mixed
     */
    public function read()
    {
        /**
         * @todo implémentation
         */
    }

    /**
     * Ecrit $contents dans le stockage
     *
     * @param  mixed $contents
     * @throws Zend_Auth_Storage_Exception Si l'écriture de $contents
     *                                     est impossible
     * @return void
     */
    public function write($contents)
    {
        /**
         * @todo implementation
         */
    }

    /**
     * RAZ du stockage
     *
     * @throws Zend_Auth_Storage_Exception Si la remise à zéro (RAZ)
     *                                     est impossible
     * @return void
     */
    public function clear()
    {
        /**
         * @todo implementation
         */
    }

}

Ensuite la classe personnalisée est invoquée, avant la requête d'authentification, avec Zend_Auth::setStorage() :

// Définit la classe personnalisée à utiliser
Zend_Auth::getInstance()->setStorage(new MonStockage());

/**
 * @todo Paramètrage de l'adaptateur d'authentification :
 *       $authAdaptateur
 */

// Authentification, sauvegarde et
// persistance du résultat en cas de succès.
$result = Zend_Auth::getInstance()->authenticate($authAdaptateur);

Utilisation de Zend_Auth

Deux manières d'utiliser les adaptateurs Zend_Auth sont proposées :

  1. indirectement, via Zend_Auth::authenticate()

  2. directement, via la méthode authenticate() de l'adaptateur

L'exemple suivant illustre la manière d'utiliser un adaptateur Zend_Auth de manière indirecte via l'utilisation de la classe Zend_Auth :

// Obtention d'une référence de l'instance du Singleton de Zend_Auth
$auth = Zend_Auth::getInstance();

// Définition de l'adaptateur d'authentification
$authAdaptateur = new MonAdaptateurAuth($identifiant, $motdepasse);

// Tentative d'authentification et stockage du résultat
$resultat = $auth->authenticate($authAdaptateur);

if (!$resultat->isValid()) {
    // Echec de l'authentification ; afficher pourquoi
    foreach ($resultat->getMessages() as $message) {
        echo "$message\n";
    }
} else {
    // Authentification réussie ; l'identité ($identifiant) est
    // stockée dans la session
    // $resultat->getIdentity() === $auth->getIdentity()
    // $resultat->getIdentity() === $identifiant
}

Une fois la tentative d'authentification réalisée, tel que montré ci-dessus, il est très simple de vérifier si une identité correctement authentifiée existe :

$auth = Zend_Auth::getInstance();
if ($auth->hasIdentity()) {
    // l'identité existe ; on la récupère
    $identite = $auth->getIdentity();
}

Pour retirer une identité du stockage persistant, utilisez simplement la méthode clearIdentity(). A utiliser typiquement pour implémenter une opération de déconnexion d'une application :

Zend_Auth::getInstance()->clearIdentity();

Quand l'utilisation automatique du stockage persistant n'est pas appropriée, le développeur peut simplement contourner l'utilisation de la classe Zend_Auth en utilisant directement une classe adaptateur. L'usage direct d'une classe adaptateur implique de configurer et préparer l'objet adaptateur et d'appeler ensuite sa méthode authenticate(). Les détails spécifiques à un adaptateur sont décrits dans la documentation de chacun d'entre-eux. L'exemple suivant utilise directement MonAdaptateurAuth :

// Définition de l'adaptateur d'authentification
$authAdaptateur = new MonAdaptateurAuth($identifiant, $motdepasse);

// Tentative d'authentification, stockage du résultat
$resultat = $authAdaptateur->authenticate();

if (!$resultat->isValid()) {
    // échec de l'authentification ; afficher pourquoi
    foreach ($resultat->getMessages() as $message) {
        echo "$message\n";
    }
} else {
    // Authentification réussie
    // $resultat->getIdentity() === $identifiant
}

Previous Next
Introduction to Zend Framework
Présentation
Installation
Zend_Acl
Introduction
Affiner les Contrôles d'Accès
Utilisation avancée
Zend_Amf
Introduction
Zend_Amf_Server
Zend_Auth
Introduction
Authentification avec une table de base de données
Authentification "Digest"
Adaptateur d'authentification HTTP
LDAP Authentication
Authentification OpenID
Zend_Cache
Introduction
Aspect théorique
Les frontends Zend_Cache
Les backends Zend_Cache
Zend_Captcha
Introduction
Opération Captcha
Adaptateurs Captcha
Zend_Config
Introduction
Aspect théorique
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Introduction à Getopt
Déclarer les règles Getopt
Extraire les options et les arguments
Configurer Zend_Console_Getopt
Zend_Controller
Zend_Controller - Démarrage rapide
Fondations de Zend_Controller
Le contrôleur frontal (Front Controller)
L'objet Requête
Routeur Standard
Le dispatcheur
Contrôleurs d'action
Aides d'action (Helper)
Objet de réponse
Plugins
Utilisation de conventions de dossiers modulaires
Exceptions avec MVC
Migrer depuis des versions précédentes
Zend_Currency
Introduction à Zend_Currency
How to work with currencies
Migrer depuis des versions antérieures
Zend_Date
Introduction
Aspect théorique
Méthodes de base
Zend_Date API Overview
Créer des dates
Constants for General Date Functions
Exemples concrets
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Relations Zend_Db_Table
Zend_Debug
Afficher des informations
Zend_Dojo
Introduction
Zend_Dojo_Data: dojo.data Envelopes
Les aides de vues Dojo
Les éléments de formulaire et les décorateurs Dojo
Zend_Dom
Introduction
Zend_Dom_Query
Zend_Exception
Utiliser les exceptions
Zend_Feed
Introduction
Importer des flux
Obtenir des flux à partir de pages Web
Consommer un flux RSS
Consommer un flux Atom
Consommer une entrée Atom particulière
Modifier la structure du flux ou des entrées
Classes personnalisées pour les flux et entrées
Zend_File
Zend_File_Transfer
Validateurs pour Zend_File_Transfer
Filtres pour Zend_File_Transfer
Migrer à partir des versions précédentes
Zend_Filter
Introduction
Classes de filtre standards
Chaînes de filtrage
Écriture de filtres
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Zend_Form Quick Start
Creating Form Elements Using Zend_Form_Element
Creating Forms Using Zend_Form
Creating Custom Form Markup Using Zend_Form_Decorator
Standard Form Elements Shipped With Zend Framework
Standard Form Decorators Shipped With Zend Framework
Internationalization of Zend_Form
Advanced Zend_Form Usage
Zend_Gdata
Introduction to Gdata
Authentification par procédé AuthSub
Using the Book Search Data API
Authentification avec ClientLogin
Using Google Calendar
Using Google Documents List Data API
Using Google Health
Using Google Spreadsheets
Using Google Apps Provisioning
Using Google Base
Utilisation des albums Web Picasa
Using the YouTube Data API
Attraper les exceptions Gdata
Zend_Http
Zend_Http_Client - Introduction
Zend_Http_Client - Utilisation avancée
Zend_Http_Client - Adaptateurs de connexion
Zend_Http_Cookie and Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Introduction
Zend_Json
Introduction
Utilisation de base
Objets JSON
XML to JSON conversion
Zend_Json_Server - JSON-RPC server
Zend_Layout
Introduction
Zend_Layout - Démarrage rapide
Zend_Layout options de configuration
Zend_Layout, utilisation avancée
Zend_Ldap
Introduction
Zend_Loader
Charger les fichiers et les classes dynamiquement
Chargeur de Plugins
Zend_Locale
Introduction
Using Zend_Locale
Normalization and Localization
Working with Dates and Times
Supported locales
Migrer à partir des versions précédentes
Zend_Log
Présentation
Rédacteurs (Writers)
Formateurs (mise en forme)
Filtres
Zend_Mail
Introduction
Envoyer des émail en utilisant SMTP
Envoyer plusieurs émail par connexion SMTP
Utiliser différents transports
Émail HTML
Fichiers joints
Ajouter des destinataires
Contrôler les limites MIME
Entêtes additionnelles
Jeux de caractères
Encodage
Authentification SMTP
Sécuriser les transports SMTP
Lire des émail
Zend_Measure
Introduction
Création d'une mesure
Récupérer des mesures
Manipuler des mesures
Types de mesures
Zend_Memory
Présentation
Manager de mémoire
Objet mémoire
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_OpenId
Introduction
Zend_OpenId_Consumer Basics
Zend_OpenId_Provider
Zend_Paginator
Introduction
Utilisation
Configuration
Utilisation avancée
Zend_Pdf
Introduction.
Créer et charger des documents PDF
Sauvegarder les changement dans un document PDF
Les pages d'un document
Dessiner
Informations du document et métadonnées.
Exemple d'utilisation du module Zend_Pdf
Zend_ProgressBar
Zend_ProgressBar
Zend_Registry
Utiliser le registre
Zend_Rest
Introduction
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Overview
Building Indexes
Searching an Index
Query Language
Query Construction API
Jeu de caractères
Extensibility
Agir avec Lucene Java
Avancé
Best Practices
Zend_Server
Introduction
Zend_Server_Reflection
Zend_Service
Introduction
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Introduction
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Bundled Services
Zend_Service_StrikeIron: Advanced Uses
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_Yahoo
Zend_Session
Introduction
Usage basique
Utilisation avancée
Gestion générale de la session
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL
Auto découverte
Zend_Test
Introduction
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Introduction
Utiliser Zend_TimeSync
Zend_Translate
Introduction
Adaptateurs pour Zend_Translate
Utiliser les adaptateurs de traduction
Migrer à partir des versions précédentes
Zend_Uri
Zend_Uri
Zend_Validate
Introduction
Classes de validation standard
Chaînes de validation
Écrire des validateurs
Zend_Version
Lire la version du Zend Framework
Zend_View
Introduction
Scripts de contrôleur
Scripts de vue
Aides de vue
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Introduction
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Configuration système requise par le Zend Framework
Version de PHP requise
Extensions PHP
Les composants du Zend Framework
Dépendances internes du Zend Framework
Convention de codage PHP du Zend Framework
Vue d'ensemble
Formatage des fichiers PHP
Conventions de nommage
Style de codage
Zend Framework Performance Guide
Introduction
Class Loading
Internationalisation (i18n) and Localisation (l10n)
View Rendering
Informations de copyright