Rechercher une fonction PHP

La classe SessionHandler

Table des matières

(PHP 5 >= 5.4.0, PHP 7)

Introduction

La classe SessionHandler est une classe spéciale qui peut être utilisée pour exposer le gestionnaire de sauvegarde de session courant en interne de PHP, par héritage. Il y a sept méthodes qui représentent les septs fonctions de rappel du gestionnaire de sauvegarde de session interne (open, close, read, write, destroy, gc et create_sid). Par défaut, cette classe va représenter ce qui est défini dans le gestionnaire de sauvegarde interne, tel que défini par la directive de configuration session.save_handler, qui vaut habituellement files par défaut. D'autres gestionnaires de sauvegarde de session interne sont fournis par des extensions PHP, comme SQLite (avec le paramètre sqlite), Memcache (avec le paramètre memcache), et Memcached (avec le paramètre memcached).

Lorsqu'une instance complète de SessionHandler est définie comme gestionnaire de sauvegarde en utilisant session_set_save_handler(), elle remplacera le gestionnaire de sauvegarde courant. Une classe étendue depuis la classe SessionHandler vous permet d'écraser les méthodes, de les intercepter, ou de les filtrer en appelant la méthode de la classe parent qui remplace en dernier lieu le gestionnaire de session interne de PHP.

Ceci vous permet, par exemple, d'interception les méthodes read et write pour crypter/décrypter les données de session, et de passer le résultat à la classe parente. Alternativement, vous pouvez aussi choisir d'écraser totalement une méthode comme la fonction de rappel de collection des gabarits gc.

En raison du fait que la classe SessionHandler se comporte comme les méthodes du gestionnaire courant de sauvegarde de sessions interne, l'exemple ci-dessus de cryptage peut être appliqué à n'importe quel gestionnaire de sauvegarde sans avoir besoin de connaître les gestionnaires internes.

Pour utiliser cette classe, vous devez commencer par définir un gestionnaire de sauvegarde que vous souhaitez exposer en utilisant session.save_handler puis, passer une instance de la classe SessionHandler ou une étendue à la fonction session_set_save_handler().

Veuillez noter que les méthodes de rappel de cette classe sont destinées à être appelées en interne par PHP, et ne sont pas prévues pour être appelées depuis le code de l'espace utilisateur. Les valeurs retournées seront utilisées de la même façon en interne par PHP. Pour plus d'informations sur le mécanisme des sessions, référez-vous à la documentation sur la fonction session_set_save_handler().

Retour à la première page de Manuel PHP  Table des matières Haut

Synopsis de la classe

SessionHandler implements SessionHandlerInterface , SessionIdInterface {
/* Méthodes */
public close ( void ) : bool
public create_sid ( void ) : string
public destroy ( string $session_id ) : bool
public gc ( int $maxlifetime ) : int
public open ( string $save_path , string $session_name ) : bool
public read ( string $session_id ) : string
public write ( string $session_id , string $session_data ) : bool
}
Avertissement

Cette classe a pour but d'exposer le gestionnaire de sauvegarde de session interne de PHP ; si vous souhaitez écrire votre gestionnaire de sauvegarde personnalisé, vous devez implémenter l'interface SessionHandlerInterface au lieu d'étendre la classe SessionHandler.

Retour à la première page de Manuel PHP  Table des matières Haut

Historique

Version Description
5.5.1 Ajout de la fonction SessionHandler::create_sid().

Exemple #1 Utilisation de la classe SessionHandler pour ajouter un cryptage aux gestionnaires de sauvegarde interne de PHP.

<?php

 /**
  * Déchiffrement AES 256
  *
  * @param data $edata
  * @param string $password
  * @return decrypted data
  */
function decrypt($edata, $password) {
    $data = base64_decode($edata);
    $salt = substr($data, 0, 16);
    $ct = substr($data, 16);

    $rounds = 3; // depends on key length
    $data00 = $password.$salt;
    $hash = array();
    $hash[0] = hash('sha256', $data00, true);
    $result = $hash[0];
    for ($i = 1; $i < $rounds; $i++) {
        $hash[$i] = hash('sha256', $hash[$i - 1].$data00, true);
        $result .= $hash[$i];
    }
    $key = substr($result, 0, 32);
    $iv  = substr($result, 32,16);

    return openssl_decrypt($ct, 'AES-256-CBC', $key, true, $iv);
  }

/**
 * Chiffrement AES 256
 *
 * @param data $data
 * @param string $password
 * @return base64 encrypted data
 */
function encrypt($data, $password) {
    // Set a random salt
    $salt = openssl_random_pseudo_bytes(16);

    $salted = '';
    $dx = '';
    // Salt the key(32) and iv(16) = 48
    while (strlen($salted) < 48) {
      $dx = hash('sha256', $dx.$password.$salt, true);
      $salted .= $dx;
    }

    $key = substr($salted, 0, 32);
    $iv  = substr($salted, 32,16);

    $encrypted_data = openssl_encrypt($data, 'AES-256-CBC', $key, true, $iv);
    return base64_encode($salt . $encrypted_data);
}

class EncryptedSessionHandler extends SessionHandler
{
    private $key;

    public function __construct($key)
    {
        $this->key = $key;
    }

    public function read($id)
    {
        $data = parent::read($id);

        if (!$data) {
            return "";
        } else {
            return decrypt($data, $this->key);
        }
    }

    public function write($id, $data)
    {
        $data = encrypt($data, $this->key);

        return parent::write($id, $data);
    }
}

// Nous interceptons le gestionnaire 'files' natif, mais ceci
// fonctionnera de la même façon avec les autres gestionnaires internes
// comme 'sqlite', 'memcache' ou 'memcached'
// qui sont fournis via des extensions PHP.
ini_set('session.save_handler', 'files');

$key = 'secret_string';
$handler = new EncryptedSessionHandler($key);
session_set_save_handler($handler, true);
session_start();

// processus pour définir et récupérer des valeurs avec la clé, depuis $_SESSION

Note:

Vu que les méthodes de cette classe sont prévues pour être appelées en interne par PHP car faisant parties du mécanisme normal des sessions, les classes enfants appèlent les méthodes parents (i.e. le gestionnaire natif interne actuellement) et doivent retourner FALSE tant que la session n'a pas encore démarrée (soit automatiquement, ou explicitement via la fonction session_start()). Ceci est très important à considérer lors de l'écriture de vos tests unitaires où les méthodes de la classe peuvent être invoquées manuellement.

Retour à la première page de Manuel PHP  Table des matières Haut

Sommaire

Rechercher une fonction PHP

Version en cache

24/11/2024 19:10:04 Cette version de la page est en cache (à la date du 24/11/2024 19:10:04) afin d'accélérer le traitement. Vous pouvez activer le mode utilisateur dans le menu en haut pour afficher la dernère version de la page.

Document créé le 30/01/2003, dernière modification le 26/10/2018
Source du document imprimé : https://www.gaudry.be/php-rf-class.sessionhandler.html

L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.

Références

  1. Consulter le document html Langue du document :fr Manuel PHP : http://php.net

Ces références et liens indiquent des documents consultés lors de la rédaction de cette page, ou qui peuvent apporter un complément d'information, mais les auteurs de ces sources ne peuvent être tenus responsables du contenu de cette page.
L'auteur de ce site est seul responsable de la manière dont sont présentés ici les différents concepts, et des libertés qui sont prises avec les ouvrages de référence. N'oubliez pas que vous devez croiser les informations de sources multiples afin de diminuer les risques d'erreurs.

Table des matières Haut