L’autenticazione è il processo in cui bisogna capire se qualcuno è realmente chi dice di essere. Per identificare l’individuo, solitamente si usa l’accoppiata username e password. Altri metodi di autenticazione sono esistenti, ad esempio, quando si paga in un negozio con la carta di credito, l’username è sostituito dal possesso materiale della carta di credito, altri metodi potrebbero essere la lettura delle impronte digitali ecc..

In Zend Framework il processo di autenticazione è gestito da un oggetto, Zend_Auth. In questo articolo, procederemo a creare un nuovo controller, AuthController e la sua rispettiva view, che visualizzerà il form per l’inserimento di username e password ed eventualmente dei messaggi di errore.

AuthController.php

< ?php

  class AuthController extends Zend_Controller_Action
  {
    public function init(){
      $response = $this->getResponse();
      $response->insert('header', $this->view->render('header.phtml'));
      $response->insert('menu', $this->view->render('menu.phtml'));
      $response->insert('columnLeft', $this->view->render('columnLeft.phtml'));
      $response->insert('columnRight', $this->view->render('columnRight.phtml'));
      $response->insert('footer', $this->view->render('footer.phtml'));
    }

    public function indexAction() {
      $this->_forward('login');
    } 

    public function loginAction() {
      $auth = Zend_Auth::getInstance();
      if ($auth->hasIdentity()) {
        $this->_redirect('/');
      }
      $flashMessenger = $this->_helper->FlashMessenger;
      $flashMessenger->setNamespace('actionErrors');
      $this->view->actionErrors = $flashMessenger->getMessages();
    }

    public function identifyAction(){
      $success = false;
      $message = '';
      if ($this->_request->isPost()){
        $formData = $this->_getFormData();

        if (empty($formData['username']) || empty($formData['password'])){
          $message = 'Please provide a username and password.';
        }else{
          $authAdapter = $this->_getAuthAdapter($formData);
          $auth = Zend_Auth::getInstance();
          $result = $auth->authenticate($authAdapter);
          if($result->isValid()) {
            $data = $authAdapter->getResultRowObject(null,'password');
            $auth->getStorage()->write($data);
            $success = true;
            $redirectUrl = $this->_redirectUrl;
          }else{
            $message = 'Login failed';
          }
        }
      }

      if(!$success){
        $flashMessenger = $this->_helper->FlashMessenger;
        $flashMessenger->setNamespace('actionErrors');
        $flashMessenger->addMessage($message);
        $redirectUrl = '/auth/login';
      }
      $this->_redirect($redirectUrl);
    }

    protected function _getAuthAdapter($formData){
      $dbAdapter = Zend_Registry::get('db');
      $authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter);
      $authAdapter->setTableName('utenti')
                  ->setIdentityColumn('username')
                  ->setCredentialColumn('password');     

      $config = Zend_Registry::get('config');
      $salt = $config->auth->salt;
      $password = sha1($salt.$formData['password']);   

      $authAdapter->setIdentity($formData['username']);
      $authAdapter->setCredential($password);         

      return $authAdapter;
    }

    protected function _getFormData(){
      $data = array();
      $filterChain = new Zend_Filter;
      $filterChain->addFilter(new Zend_Filter_StripTags);
      $filterChain->addFilter(new Zend_Filter_StringTrim);

      $data['username'] = $filterChain->filter($this->_request->getPost('username'));
      $data['password'] = $filterChain->filter($this->_request->getPost('password'));
      return $data;
    }

    public function logoutAction() {
      $auth = Zend_Auth::getInstance();
      $auth->clearIdentity();
      $this->_redirect('/');
    }
  }

Come per l’IndexController anche questo AuthController contiene il metodo init() utile all’inserimento nell’output delle parti comuni del layout (header, footer ecc.. ).

L’indexAction altro non contiene che una redirezione alla loginAction, in modo tale che entrando nella pagina di autorizzazione senza specificare una action, login venga eseguita. La LoginAction redireziona l’output nell’IndexController ( quindi nella homepage ) del sito nel caso in cui l’utente sia già autorizzato, ovvero nel caso in cui $auth->hasIdentity() ritorni true. Inoltre viene recuperato l’helper FlashMessenger, che contiene eventuali messaggi salvati da una precedente azione, salvati nella proprietà $this->view->actionErrors, in modo tale da poterli visualizzare nella vista.
Alla loginAction è legata la view login.phtml, il seguente è il codice:

login.phtml

<h1>Log in</h1>
<p>Please log in here</p>
<?php echo isset($this->actionErrors[0]) && !empty($this->actionErrors[0]) ? "<p class='error'>" . $this->escape($this->actionErrors[0]) . "</p>" : ""; ?>

<form method="POST"
        action="<?php echo $this->LinkTo('auth/identify'); ?>">
    <div>
        <label>Username</label>
        <input type="text" name="username" value="" />
    </div>
    <div>
        <label>Password</label>
        <input type="password" name="password" value="" />
    </div>
    <div>
        <input type="submit" name="login" value="Login" />
    </div>
</form>

L’unico particolare degno di nota di questo file è l’attributo action del form. Questo è generato da un view helper, LinkTo che si occupa di creare la corretta url per la identifyAction, recuperando il valore corretto di $baseUrl.

LinkTo.php

< ?php

  class Zend_View_Helper_LinkTo
  {
    protected static $baseUrl = null; 

    public function linkTo($path){
      if(self::$baseUrl === null){
        $request = Zend_Controller_Front::getInstance()->getRequest();
        $root = '/' . trim($request->getBaseUrl(), '/');
        if ($root == '/'){
          $root = '';
        }
        self::$baseUrl = $root . '/';
      }
      return self::$baseUrl . ltrim($path, '/');
    }
  }

Procedendo con le action dell’AuthController troviamo l’identifyAction, che controlla l’esistenza di una richiesta POST, quindi filtra il contenuto dell’array POST passandolo al metodo _getFormData

, che filtra il suo contenuto utilizzando l’oggetto Zend_Filter e aggiungendo come filtri gli oggetti Zend_Filter_StripTags e Zend_Filter_StringTrim, il cui compito è il medesimo delle funzioni built in del linguaggio trim() e strip_tags.

I dati inviati vengono quindi passati al metodo _getAuthAdapter che si occupa di istanziare la classe Zend_Auth_Adapter_DbTable a quale passeremo l’oggetto $db recuperato dal registro ed indicheremo la tabella e i campi in cui dovranno essere verificati l’username e la password inviate. Per rendere il tutto più sicuro la password, oltre ad essere salvata criptata sul database tramite l’algoritmo SHA1, è unita ad un salt, una stringa casuale salvata nel nostro file di configurazione, il che rende estremamente difficile, se non impossibile, recuperare il valore della password conoscendo il suo valore criptato e cercando di effettuare un reverse engineering.

L’oggetto Zend_Auth_Adapter_DbTable ritornato dal nostro metodo _getAuthAdapter sarà quindi passato a Zend_Auth, che ci confermerà o meno l’esistenza dell’utente tramite la chiamata del metodo sValid(). In caso di fallimento l’output sarà redirezionato alla medesima pagina di autenticazione accompagnata dal messaggio indicante la non riuscita dell’operazione. In caso di successo, i dati utente recuperati saranno salvati nella sessione, fatta eccezione che per la password.

Messaggio di benvenuto

In ogni sito che si rispetti, una volta autenticati il sistema ci da un messaggio di benvenuto, indicante il nostro nome. Ebbene, anche il nostro sistema godrà di questa caratteristica, utilizzando un nuovo view helper, LoggedInUser.

LoggedInUser

< ?php
  class Zend_View_Helper_LoggedInUser {
    protected $_view; 

    function setView($view) {
      $this->_view = $view;
    }

    function loggedInUser(){
      $auth = Zend_Auth::getInstance();
      if($auth->hasIdentity()){
        $logoutUrl = $this->_view->linkTo('auth/logout');
        $user = $auth->getIdentity();
        $username = $this->_view->escape(ucfirst($user->username));
        $string = 'Loggato come ' . $username . ' | Log out';
      }else{
        $loginUrl = $this->_view->linkTo('auth/login');
        $string = 'Log in';
      }
      return $string;
    }
  }

La stringa ritornata sarà visualizzata, per esempio, nell’header.

header.phtml

Paesidelmondo Header

 

  
Registratione
  Nome Utente:

 



< ?php echo $this->LoggedInUser();?>

Con questo si conclude il tutorial all’autenticazione con Zend Framework. I commenti, aggiunte, correzioni o altro sono sempre graditi.

Related posts:

1. Zend Framework: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...
2. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...

Related posts brought to you by Yet Another Related Posts Plugin.

A che servono le sessioni? Che cosa sono?
Le sessioni servono al fine di poter implementare sezioni protette da username e password sul proprio sito internet / gestionale web o per salvare dei dati in maniera globale. Le sessioni funzionano tramite un cookie quindi per funzionare correttamente vi è la necessità che il client abbia i permessi per accettare i cookie. In caso fossero disattivati, php da la possibilità di utilizzare di propagare l’id di sessione utilizzando le url sel sistema, solo se ’session.use_trans_sid’ è settata nel php.ini.

Ad oggi le funzioni che gestiscono la sessione sono in tutto 20, per eventuali approfondimenti potete guardare qui. In questo articolo ci limiteremo a trattare le seguenti:

• session_ destroy
• session_ id
• session_ is_ registered
• session_ register
• session_ start
• session_ unregister
• session_ unset

Prima di cominciare vorrei fare una piccola premessa.
Spesso utilizzerò la funzione var_dump, funzione molto utile a livello di debug in quanto mostra tipo, lunghezza e soprattutto valore delle espressioni passate ad argomento.
Inoltre, per testare i vari codici che seguiranno, vi consiglio di creare 3 files differenti, uno chiamato session_starter.php, uno session_checker.php ed infine session_destroyer.php che serviranno rispettivamente per inizializzare la sessione ed inserire dati al suo interno, per visualizzare il contenuto della sessione ed infine per distruggere la sessione.

1) Inizializzare la sessione

A meno che sul php.ini non sia specificato session.auto_start uguale a 1 ( di default è 0 ) per poter utilizzare la sessione all’interno dei nostri script sarà necessario inizializzarla. Quindi, la prima riga del nostro script sarà

// Inizializza la sessione
session_start();

2) Visualizzare l’id di sessione corrente

Da questo momento in poi potremo utilizzare anche le altre funzionalità che php mette a disposizione. Proviamo dunque ad utilizzare la funzione session_id() all’interno del nostro script

// Visualizziamo l'attuale id di sessione
echo session_id();

Che visualizzerà qualcosa del genere: 28d7c083fccb973b56972cc448b72310

Ma che cos’è l’ID di sessione?

L’id di sessione contraddistingue univocamente due files di testo, un cookie salvato sul vostro PC e un file contenente i dati di sessione salvato sul server remoto.
Per visualizzare il cookie in locale, utilizzando Firefox, selezionare Strumenti -> Opzioni -> Privacy -> Mostra Cookie: visualizzerete diverse cartelle ognuna delle quali corrisponde ad un sito visitato che vi ha inviato un cookie. Aprite la cartella relativa al dominio in cui state testando i vostri script ( se siete in locale sarà localhost ). Questo è ciò che vedrete

Dov’è salvata la sessione sul server? Di default la sessione viene salvata all’interno di una directory chiamata ‘tmp’. Per verificare l’esatto percorso visualizzare la stringa ritornata da questa funzione: ini_get(’session.save_path’);
Questo è un esempio di ciò che troverete:

Noterete un file con prefisso sess_ seguito dall’identificativo della sessione ( è probabile che all’interno di tmp esistano numerosi file sess_* ), nel mio caso sess_28d7c083fccb973b56972cc448b72310. Apritelo con un qualsiasi editor di testo, noterete che è vuoto in quanto non abbiamo ancora inserito nulla all’interno della sessione.

3) Inserimento dei dati all’interno della sessione

Inserire i dati all’interno dell’array di sessione è molto semplice, un esempio vale più di mille parole

$_SESSION['test'] = "blah";

Proviamo a vedere cosa è successo al file di testo sul server contenente i dati di sessione, vedremo che al suo interno è stata inserita la seguente stringa: test|s:4:”blah”;
Questo non è nient’altro che la nostra variabile serializzata, analizzarla è molto semplice:
test è il nome della variabile che abbiamo inserito, s è il tipo di variabile ( stringa ), blah è il valore che gli abbiamo attribuito.

Proviamo ad aggiungere un’altra variabile, un array ad esempio

$_SESSION['mioArray'] = array(1 => 'uno', 'due' => 2);

Il nostro file di sessione sarà modificato e questa sarà la stringa al suo interno: test|s:4:”blah”;mioArray|a:2:{i:1;s:3:”uno”;s:3:”due”;i:2;}, il risultato si spiega da solo:
mioArray è il nome della variabile, a il tipo ( array ), 2 la lunghezza e all’interno delle graffe i valori i:1;s:3:”uno”; e s:3:”due”;i:2; che rappresentano le coppie chiave valore ( i sta per integer ).
Da notare che la situazione sarebbe stata la stessa usando il seguente codice

$mioArray = array(1 => 'uno', 'due' => 2)
$_SESSION['mioArray'] = $mioArray;

Allo stesso modo è possibile salvare degli oggetti all’interno della sessione.
Creiamo quindi una semplicissima classe la cui istanza sarà salvata nella sessione

class miaClasse{
public $variabilePubblica;
private $variabilePrivata;
public function __construct(){
$this->variabilePubblica = 1;
$this->variabilePrivata = 2;
}
}

$obj = new miaClasse();
$_SESSION['mioOggetto'] = $obj;

Provate da voi a vedere le modifiche all’interno del file di sessione.

4) Comportamenti Anomali

Ad oggi ho riscontrato i seguenti comportamenti anomali della sessione:

Primo
Provate ad eseguire il seguente codice

$_SESSION['26'] = 'Prova';
echo $_SESSION['26'];

Otterrete esattamente ciò che vi aspettate, ovvero ‘Prova‘.
Eseguite quindi solo la seconda linea di codice, non notate qualcosa di strano?
Non viene stampato nulla su schermo, sembra che la nostra variabile ‘26′ sia scomparsa nel nulla, e difatti è così.
A meno che non esista un qualche parametro di configurazione di cui non conosca l’esistenza, sembra che creando una variabile contenente esclusivamente dei numeri, che sia stringa o meno ( quindi tra apici o meno ), php non lo salvi nella sessione.

Per chiarire questa situazione ho effettuato varie prove, tra cui l’utilizzo della funzione session_register(). Prima di esporvi i risultati di queste prove e il caso di scrivere due righe sulle funzioni session_register(), session_is_registered() e session_unregister(). Queste 3 funzioni erano utilizzate soprattutto nelle versioni precedenti di php, quando la direttiva register globals era spesso settata su ‘on’. Oggi se ne sconsiglia l’utilizzo.

La seguente è stata la prova da me effettuata:

session_register('26');
$_SESSION['26'] = 'Prova';

Eseguendo var_dump($_SESSION) noteremo che l’indice numerico è stato correttamente salvato nella sessione ma con valore NULL. Non abbiamo risolto nulla ma sappiamo qualcosa in più sul comportamento della sessione. Quindi evitiamo di salvare chiavi solo numeriche all’interno della sessione.

Secondo
Inserite tutte le variabili che volete nella sessione, quindi eseguite il seguente codice:

$_SESSION["foo|bar"] = "foo";

Controllate il contenuto della sessione, noterete che è stato cancellato completamente. Questo comportamento è causato dal carattere ‘|’, quindi evitate di utilizzarlo.
Questo è comunque un bug conosciuto di php, potete trovare ulteriori informazioni qui

5) Distruggere la sessione

Per distrugger la sessione si utilizza la funzione session_destroy(). Questa funzione una volta chiamata causa l’eliminazione di tutto il contenuto presente all’interno del file di sessione sul server.
Per maggiore sicurezza sull’eliminazione di questi dati alla chiamata di questa funzione affianchiamo $_SESSION = array();.
I dati possono anche essere rimossi dalla sessione utilizzando session_unset(), funzione che può essere tranquillamente omessa utilizzando il metodo sopra citato.
Infine, per eliminare definitivamente il file fisico dal server effettuiamo la seguente chiamata setcookie(session_name(),”,time()-3600) che setta la scadenza del cookie ad ‘un ora fa’.
Notate che l’eliminazione della sessione non cambia in automatico l’id di sessione, infatti, aggiungendo dati all’interno della sessione dopo averla eliminata sarà ricreato sul server un file con lo stesso nome del precedente ma con i nuovi dati inseriti.

Per ora è tutto, spero di aver fatto più chiarezza sull’argomento sessioni.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.