mirror of
https://github.com/php/doc-pt_br.git
synced 2026-03-23 22:52:12 +01:00
238 lines
8.4 KiB
XML
238 lines
8.4 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<!-- EN-Revision: 62126c55f1c6ed444043e7272c4f9e233818a44b Maintainer: leonardolara Status: ready --><!-- CREDITS: marcosmarcolin,leonardolara -->
|
|
<phpdoc:classref xml:id="class.sessionhandler" xmlns:phpdoc="http://php.net/ns/phpdoc" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xi="http://www.w3.org/2001/XInclude">
|
|
|
|
<title>A classe SessionHandler</title>
|
|
<titleabbrev>SessionHandler</titleabbrev>
|
|
|
|
<partintro>
|
|
|
|
<!-- {{{ SessionHandler intro -->
|
|
<section xml:id="sessionhandler.intro">
|
|
&reftitle.intro;
|
|
<para>
|
|
<classname>SessionHandler</classname> é uma classe especial que pode ser usada
|
|
para expor o manipulador interno atual do PHP de gravação de sessão por herança.
|
|
Existem sete métodos que envolvem (wrap) as sete funções internas de callbacks do manipulador de gravação
|
|
de sessão (<parameter>open</parameter>, <parameter>close</parameter>,
|
|
<parameter>read</parameter>, <parameter>write</parameter>,
|
|
<parameter>destroy</parameter>, <parameter>gc</parameter> e
|
|
<parameter>create_sid</parameter>). Por padrão, esta classe vai envolver
|
|
qualquer manipulador de gravação interno definido pela diretiva de configuração
|
|
<link linkend="ini.session.save-handler">session.save_handler</link>,
|
|
que normalmente é <parameter>files</parameter> por
|
|
padrão. Outros manipuladores internos de gravação de sessão podem ser fornecidos por
|
|
extensões do PHP, como por exemplo SQLite (como <parameter>sqlite</parameter>), Memcache (como
|
|
<parameter>memcache</parameter>), e Memcached (como
|
|
<parameter>memcached</parameter>).
|
|
</para>
|
|
<para>
|
|
Quando uma instância de <classname>SessionHandler</classname> é definida como manipulador de gravação usando
|
|
<function>session_set_save_handler</function>, ela envolverá o manipulador de gravação atual.
|
|
Uma classe que estende <classname>SessionHandler</classname> permite sobrescrever
|
|
os métodos, interceptá-los ou filtrá-los chamando os métodos da classe pai que envolvem os
|
|
manipuladores de sessão internos do PHP.
|
|
</para>
|
|
<para>
|
|
Isto permite, por exemplo, interceptar os métodos <parameter>read</parameter> e <parameter>write</parameter>
|
|
para criptografar/descriptografar os dados de sessão e então passar o resultado de e para a classe pai.
|
|
Alternativamente, pode-se sobrescrever completamente um método como o callback de limpeza
|
|
<parameter>gc</parameter>.
|
|
</para>
|
|
<para>
|
|
Como o <classname>SessionHandler</classname> envolve os manipuladores de gravação
|
|
atuais, o exemplo acima de criptografia pode ser aplicado em qualquer manipulador de gravação interno sem
|
|
precisar saber o funcionamento interno dos manipuladores.
|
|
</para>
|
|
<para>
|
|
Para usar esta classe, primeiro configure o manipulador de gravação que você quer expor usando
|
|
<link linkend="ini.session.save-handler">session.save_handler</link> e então passe uma instância de
|
|
<classname>SessionHandler</classname> ou uma classe que a estenda para <function>session_set_save_handler</function>.
|
|
</para>
|
|
<para>
|
|
Note que os métodos de callbacks desta classe são projetados para serem chamados internamente pelo
|
|
PHP e não para serem chamados pelo código do usuário. Os valores de retorno são igualmente processados internamente
|
|
pelo PHP. Para mais informações do fluxo de trabalho da sessão, consulte <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>
|
|
Esta classe é projetada para expor o manipulador interno do PHP de gravação de sessão; se você quiser
|
|
escrever manipuladores de gravação personalizados, implemente a interface <classname>SessionHandlerInterface</classname>
|
|
ao invés de estender a classe <classname>SessionHandler</classname>.
|
|
</para>
|
|
</warning>
|
|
</section>
|
|
|
|
<section xml:id="sessionhandler.examples">
|
|
&reftitle.examples;
|
|
<example>
|
|
<title>
|
|
Usando <classname>SessionHandler</classname> para adicionar criptografia aos manipuladores internos do PHP de gravação.
|
|
</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; // depende do comprimento da chave
|
|
$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) {
|
|
// Gera um salt aleatório criptograficamente seguro usando random_bytes()
|
|
$salt = random_bytes(16);
|
|
|
|
$salted = '';
|
|
$dx = '';
|
|
// Salt em key(32) e 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);
|
|
}
|
|
}
|
|
|
|
// iremos interceptar o manipulador nativo de arquivos, mas trabalharemos igualmente
|
|
// com outros manipuladores internos como 'sqlite', 'memcache' ou 'memcached'
|
|
// que são disponibilizados por extensões do PHP
|
|
ini_set('session.save_handler', 'files');
|
|
|
|
$key = 'secret_string';
|
|
$handler = new EncryptedSessionHandler($key);
|
|
session_set_save_handler($handler, true);
|
|
session_start();
|
|
|
|
// proceder para definir e recuperar os valores pela chave de $_SESSION
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
<note>
|
|
<para>
|
|
Como os métodos dessa classe são projetados para serem chamados internamente pelo PHP como parte do fluxo normal da sessão,
|
|
chamadas à esses métodos (ou seja, os manipuladores internos nativos reais) por classes filhas irão retornar &false;, a não ser que
|
|
a sessão tenha sido iniciada (independente se foi de forma automática ou pela chamada de <function>session_start</function>).
|
|
É importante levar isto em consideração quando escrever testes unitários onde os métodos da classe podem ser invocados manualmente.
|
|
</para>
|
|
</note>
|
|
</section>
|
|
|
|
</partintro>
|
|
|
|
&reference.session.entities.sessionhandler;
|
|
|
|
</phpdoc:classref>
|
|
<!-- 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
|
|
-->
|