mirror of
https://github.com/macintoshplus/doc-fr.git
synced 2026-03-24 17:02:18 +01:00
252 lines
8.8 KiB
XML
252 lines
8.8 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<!-- EN-Revision: 62126c55f1c6ed444043e7272c4f9e233818a44b Maintainer: yannick Status: ready -->
|
|
<!-- Reviewed: no -->
|
|
<reference xml:id="class.sessionhandler" role="class" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xi="http://www.w3.org/2001/XInclude">
|
|
|
|
<title>La classe SessionHandler</title>
|
|
<titleabbrev>SessionHandler</titleabbrev>
|
|
|
|
<partintro>
|
|
|
|
<!-- {{{ SessionHandler intro -->
|
|
<section xml:id="sessionhandler.intro">
|
|
&reftitle.intro;
|
|
<para>
|
|
La classe <classname>SessionHandler</classname> 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 sept fonctions de rappel du gestionnaire de sauvegarde
|
|
de session interne (<parameter>open</parameter>, <parameter>close</parameter>,
|
|
<parameter>read</parameter>, <parameter>write</parameter>,
|
|
<parameter>destroy</parameter>, <parameter>gc</parameter> et
|
|
<parameter>create_sid</parameter>). 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 <link linkend="ini.session.save-handler">session.save_handler</link>,
|
|
qui vaut habituellement <parameter>files</parameter> par défaut. D'autres
|
|
gestionnaires de sauvegarde de session interne sont fournis par des
|
|
extensions PHP, comme SQLite (avec le paramètre <parameter>sqlite</parameter>),
|
|
Memcache (avec le paramètre <parameter>memcache</parameter>), et Memcached (avec
|
|
le paramètre <parameter>memcached</parameter>).
|
|
</para>
|
|
<para>
|
|
Lorsqu'une instance complète de <classname>SessionHandler</classname> est définie comme
|
|
gestionnaire de sauvegarde en utilisant <function>session_set_save_handler</function>, elle
|
|
remplacera le gestionnaire de sauvegarde courant. Une classe étendue depuis la classe
|
|
<classname>SessionHandler</classname> 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.
|
|
</para>
|
|
<para>
|
|
Ceci vous permet, par exemple, d'interception les méthodes <parameter>read</parameter> et
|
|
<parameter>write</parameter> 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
|
|
<parameter>gc</parameter>.
|
|
</para>
|
|
<para>
|
|
En raison du fait que la classe <classname>SessionHandler</classname> 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.
|
|
</para>
|
|
<para>
|
|
Pour utiliser cette classe, vous devez commencer par définir un gestionnaire de sauvegarde
|
|
que vous souhaitez exposer en utilisant <link linkend="ini.session.save-handler">session.save_handler</link>
|
|
puis, passer une instance de la classe <classname>SessionHandler</classname> ou une étendue à la
|
|
fonction <function>session_set_save_handler</function>.
|
|
</para>
|
|
<para>
|
|
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 <function>session_set_save_handler</function>.
|
|
</para>
|
|
</section>
|
|
<!-- }}} -->
|
|
|
|
<section xml:id="sessionhandler.synopsis">
|
|
&reftitle.classsynopsis;
|
|
|
|
<!-- {{{ Synopsis -->
|
|
<classsynopsis class="class">
|
|
<ooclass>
|
|
<classname>SessionHandler</classname>
|
|
</ooclass>
|
|
|
|
<oointerface>
|
|
<modifier>implements</modifier>
|
|
<interfacename>SessionHandlerInterface</interfacename>
|
|
</oointerface>
|
|
|
|
<oointerface>
|
|
<interfacename>SessionIdInterface</interfacename>
|
|
</oointerface>
|
|
|
|
<classsynopsisinfo role="comment">&Methods;</classsynopsisinfo>
|
|
<xi:include xpointer="xmlns(db=http://docbook.org/ns/docbook) xpointer(id('class.sessionhandler')/db:refentry/db:refsect1[@role='description']/descendant::db:methodsynopsis[@role='SessionHandler'])">
|
|
<xi:fallback/>
|
|
</xi:include>
|
|
</classsynopsis>
|
|
<!-- }}} -->
|
|
|
|
</section>
|
|
|
|
<section xml:id="session.notes">
|
|
&reftitle.notes;
|
|
<warning>
|
|
<para>
|
|
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 <classname>SessionHandlerInterface</classname> au lieu d'étendre
|
|
la classe <classname>SessionHandler</classname>.
|
|
</para>
|
|
</warning>
|
|
</section>
|
|
|
|
<section xml:id="sessionhandler.examples">
|
|
&reftitle.examples;
|
|
<example>
|
|
<title>
|
|
Utilisation de la classe <classname>SessionHandler</classname>
|
|
pour ajouter un cryptage aux gestionnaires de sauvegarde interne de PHP.
|
|
</title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?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) {
|
|
// Générer un sel aléatoire cryptographiquement sécurisé en utilisant random_bytes()
|
|
$salt = random_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
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
<note>
|
|
<para>
|
|
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
|
|
<function>session_start</function>). 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.
|
|
</para>
|
|
</note>
|
|
</section>
|
|
|
|
</partintro>
|
|
|
|
&reference.session.entities.sessionhandler;
|
|
|
|
</reference>
|
|
<!-- Keep this comment at the end of the file
|
|
Local variables:
|
|
mode: sgml
|
|
sgml-omittag:t
|
|
sgml-shorttag:t
|
|
sgml-minimize-attributes:nil
|
|
sgml-always-quote-attributes:t
|
|
sgml-indent-step:1
|
|
sgml-indent-data:t
|
|
indent-tabs-mode:nil
|
|
sgml-parent-document:nil
|
|
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
|
|
sgml-exposed-tags:nil
|
|
sgml-local-catalogs:nil
|
|
sgml-local-ecat-files:nil
|
|
End:
|
|
vim600: syn=xml fen fdm=syntax fdl=2 si
|
|
vim: et tw=78 syn=sgml
|
|
vi: ts=1 sw=1
|
|
-->
|