mirror of
https://github.com/php/doc-de.git
synced 2026-03-24 15:22:14 +01:00
261 lines
8.6 KiB
XML
261 lines
8.6 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<!-- $Revision$ -->
|
|
<!-- EN-Revision: 62126c55f1c6ed444043e7272c4f9e233818a44b Maintainer: samesch 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>Die Klasse SessionHandler</title>
|
|
<titleabbrev>SessionHandler</titleabbrev>
|
|
|
|
<partintro>
|
|
|
|
<!-- {{{ SessionHandler intro -->
|
|
<section xml:id="sessionhandler.intro">
|
|
&reftitle.intro;
|
|
<para>
|
|
<classname>SessionHandler</classname> ist eine spezielle Klasse, die
|
|
verwendet werden kann, um den aktuellen internen
|
|
PHP-Session-Speicherverwalter (PHP Session Save Handler) durch Vererbung
|
|
zugänglich zu machen. Es gibt sieben Methoden, die die Wrapper für die
|
|
sieben internen Callbacks des Session-Speicherverwalters sind
|
|
(<parameter>open</parameter>, <parameter>close</parameter>,
|
|
<parameter>read</parameter>, <parameter>write</parameter>,
|
|
<parameter>destroy</parameter>, <parameter>gc</parameter> und
|
|
<parameter>create_sid</parameter>). Standardmäßig ist diese Klasse der
|
|
Wrapper für den internen Speicherverwalter, der durch die
|
|
Konfigurationsdirektive
|
|
<link linkend="ini.session.save-handler">session.save_handler</link>
|
|
definiert ist (normalerweise <parameter>files</parameter>). Andere interne
|
|
Session-Speicherverwalter werden von PHP-Erweiterungen wie SQLite (als
|
|
<parameter>sqlite</parameter>), Memcache (als
|
|
<parameter>memcache</parameter>), und Memcached (als
|
|
<parameter>memcached</parameter>) bereitgestellt.
|
|
</para>
|
|
<para>
|
|
Wenn eine einfache Instanz von <classname>SessionHandler</classname>
|
|
mittels <function>session_set_save_handler</function> als Speicherverwalter
|
|
festgelegt wird, wird sie zum Wrapper für den aktuellen Speicherverwalter.
|
|
Eine Klasse, die von <classname>SessionHandler</classname> abgeleitet ist,
|
|
erlaubt es, Methoden zu überschreiben, abzufangen oder zu filtern, indem
|
|
die Methoden der Elternklasse aufgerufen werden, die letztendlich Wrapper
|
|
für die internen PHP-Sessionverwalter sind.
|
|
</para>
|
|
<para>
|
|
So können zum Beispiel die Methoden <parameter>read</parameter> und
|
|
<parameter>write</parameter> abgefangen werden, um die Session-Daten zu
|
|
verschlüsseln bzw. zu entschlüsseln und dann das Ergebnis an die
|
|
übergeordnete Klasse zu übergeben. Alternativ könnte auch eine Methode wie
|
|
der Garbage Collection Callback <parameter>gc</parameter> komplett
|
|
überschrieben werden.
|
|
</para>
|
|
<para>
|
|
Da der <classname>SessionHandler</classname> ein Wrapper für die Methoden
|
|
des aktuellen internen Speicherverwalters ist, kann das obige Beispiel der
|
|
Verschlüsselung auf jeden internen Speicherverwalter angewendet werden,
|
|
ohne dass die Interna des Verwalters bekannt sein müssen.
|
|
</para>
|
|
<para>
|
|
Um diese Klasse zu verwenden, muss zuerst der gewünschte Speicherverwalter
|
|
mit <link linkend="ini.session.save-handler">session.save_handler</link>
|
|
festgelegt werden und dann eine Instanz von
|
|
<classname>SessionHandler</classname> oder eine Erweiterung davon an
|
|
<function>session_set_save_handler</function> übergeben werden.
|
|
</para>
|
|
<para>
|
|
Es ist zu beachten, dass die Callback-Methoden dieser Klasse dazu gedacht
|
|
sind, intern von PHP aufgerufen zu werden und nicht aus dem
|
|
Anwenderprogramm aufgerufen werden sollen. Auch die Rückgabewerte werden
|
|
intern von PHP verarbeitet. Weitere Informationen über den Ablauf von
|
|
Sessions sind im Abschnitt <function>session_set_save_handler</function>
|
|
zu finden.
|
|
</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>
|
|
Diese Klasse wurde entwickelt, um den aktuellen internen
|
|
PHP-Session-Speicherverwalter darzustellen. Wenn eine eigene
|
|
Speicherungsverwaltung benötigt wird, sollte die Schnittstelle
|
|
<classname>SessionHandlerInterface</classname> implementiert werden,
|
|
anstatt <classname>SessionHandler</classname> zu erweitern.
|
|
</para>
|
|
</warning>
|
|
</section>
|
|
|
|
<section xml:id="sessionhandler.examples">
|
|
&reftitle.examples;
|
|
<example>
|
|
<title>
|
|
Die Verwendung von <classname>SessionHandler</classname>, um den internen
|
|
PHP-Speicherverwalter mit Verschlüsselung zu versehen
|
|
</title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
/**
|
|
* decrypt 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; // abhängig von der Schlüssellänge
|
|
$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);
|
|
}
|
|
|
|
/**
|
|
* crypt AES 256
|
|
*
|
|
* @param data $data
|
|
* @param string $password
|
|
* @return base64 encrypted data
|
|
*/
|
|
function encrypt($data, $password) {
|
|
// Ein kryptographisch sicheres Zufallssalz mit random_bytes() erzeugen
|
|
$salt = random_bytes(16);
|
|
|
|
$salted = '';
|
|
$dx = '';
|
|
// key(32) und iv(16) mit Salz versehen = 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);
|
|
}
|
|
}
|
|
|
|
// Wir verwenden den nativen 'files'-Handler, aber es funktioniert auch
|
|
// mit anderen internen nativen Handlern wie 'sqlite', 'memcache' oder
|
|
// 'memcached', die von PHP-Erweiterungen bereitgestellt werden.
|
|
ini_set('session.save_handler', 'files');
|
|
|
|
$key = 'secret_string';
|
|
$handler = new EncryptedSessionHandler($key);
|
|
session_set_save_handler($handler, true);
|
|
session_start();
|
|
|
|
// Fortfahren mit dem Setzen und Abrufen von Werten anhand der
|
|
// Schlüssel von $_SESSION
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
<note>
|
|
<para>
|
|
Da die Methoden dieser Klasse so konzipiert sind, dass sie als Teil des
|
|
normalen Ablaufs einer Session intern von PHP aufgerufen werden, geben
|
|
Aufrufe der Kindklasse an die Elternmethoden (&dh; die eigentlichen
|
|
internen nativen Prozeduren) &false; zurück, es sei denn, die Session
|
|
wurde tatsächlich gestartet (entweder automatisch oder durch den
|
|
expliziten Aufruf von <function>session_start</function>). Es ist
|
|
wichtig, dies beim Schreiben von Unit-Tests zu beachten, bei denen die
|
|
Methoden der Klasse manuell aufgerufen werden können.
|
|
</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
|
|
-->
|