archived-doc-pt-br/appendices/filters.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 3f1dbc451b313fb1ec8058f24c1beccf55fce316 Maintainer: leonardolara Status: ready --><!-- CREDITS: narigone,diegopires,adiel,fibbarth,ae,leonardolara -->
<appendix xml:id="filters" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
 <title>Lista de Filtros Disponíveis</title>
 <para>
  A seguir está uma lista de alguns filtros internos de fluxo para
  uso com <function>stream_filter_append</function>.
  Sua versão do PHP pode ter mais filtros (ou menos) que os
  listados aqui.
 </para>

 <para>
  Vale notar que existe uma leve assimetria entre
  <function>stream_filter_append</function>
  e <function>stream_filter_prepend</function>.
  Todo fluxo no PHP contém um pequeno <emphasis>buffer de leitura</emphasis>
  onde ele guarda blocos de dados recuperados do
  sistema de arquivos ou outro recurso (resource) com o propósito de processar dados
  da maneira mais eficiente. Assim que os dados são recuperados
  do recurso para o buffer interno do fluxo, eles
  são processados imediatamente por qualquer filtro anexo quer esteja
  a aplicação PHP preparada para receber os dados ou não.
  Se os dados estão esperando no buffer de leitura quando um filtro for
  <emphasis>anexado</emphasis>, esses dados serão imediatamente
  processados através daquele filtro, tornando transparente o fato de eles estarem
  esperando no buffer. No entanto, se os dados estão
  esperando no buffer de leitura quando um filtro é
  <emphasis>prefixado</emphasis>, esses dados <emphasis>NÃO</emphasis> serão
  processados por este filtro. Ao invés disso, eles esperarão até
  o próximo bloco de dados ser recuperado do recurso.
 </para>

 <para>
  Para uma lista dos filtros instalados na sua versão do
  PHP use <function>stream_get_filters</function>.
 </para>

 <section xml:id="filters.string">
  <title>Filtros de String</title>

  <simpara>
   Cada um destes filtros faz precisamente o que o seu nome implica e
   corresponde ao comportamento da função interna de tratamento de string homônima.
   Para mais informações sobre um determinado filtro, veja a página do manual para
   a função correspondente.
  </simpara>

  <section xml:id="filters.string.rot13">
   <title>string.rot13</title>
   <simpara>
    O uso desse filtro é equivalente a processar todos os dados do fluxo com
    a função <function>str_rot13</function>.
   </simpara>
   <example>
    <title>string.rot13</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.rot13');
fwrite($fp, "Isto é um teste.\n");
/* Saída:    Vfgb é hz grfgr.   */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.toupper">
   <title>string.toupper</title>
   <simpara>
    O uso desse filtro é equivalente a processar todos os dados do fluxo com
    a função <function>strtoupper</function>.
   </simpara>
   <example>
    <title>string.toupper</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.toupper');
fwrite($fp, "Isto é um teste.\n");
/* Saída:    ISTO é UM TESTE.   */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.tolower">
   <title>string.tolower</title>
   <simpara>
    O uso desse filtro é equivalente a processar todos os dados do fluxo com
    a função <function>strtolower</function>.
   </simpara>
   <example>
    <title>string.tolower</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.tolower');
fwrite($fp, "Isto é um teste.\n");
/* Saída:    isto é um teste.   */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.strip_tags">
   <title>string.strip_tags</title>
   <simpara>
    O uso desse filtro é equivalente a processar todos os dados do fluxo com
    a função <function>strip_tags</function>.
    Ela aceita parâmetros em uma das duas formas:
    Ou como uma string contendo uma lista de tags similares ao
    segundo parâmetro da função <function>strip_tags</function>,
    ou como um array com os nomes das tags.
   </simpara>
   &warn.deprecated.feature-7-3-0;
   <example>
    <title>string.strip_tags</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.strip_tags', STREAM_FILTER_WRITE, "<b><i><u>");
fwrite($fp, "<b>texto em negrito</b> aumentado para um <h1>heading de nível 1</h1>\n");
fclose($fp);
/* Saída :   texto em negrito</b> aumentado para um heading de nível 1   */

$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.strip_tags', STREAM_FILTER_WRITE, array('b','i','u'));
fwrite($fp, "<b>texto em negrito</b> aumentado para um <h1>heading de nível 1</h1>\n");
fclose($fp);
/* Saída:    texto em negrito</b> aumentado para um heading de nível 1   */
?>
]]>
    </programlisting>
   </example>
  </section>
 </section>

 <section xml:id="filters.convert">
  <title>Filtros de Conversão</title>

  <simpara>
   Como todos os filtros string.*, os filtros convert.* realizam ações
   similares aos seus nomes.
   Para mais informações sobre um determinado filtro, veja a página do manual para
   a função correspondente.
  </simpara>

  <section xml:id="filters.convert.base64">
   <title>convert.base64-encode e convert.base64-decode</title>
   <simpara>
    O uso desses filtros é equivalente a processar todos os dados do fluxo com as
    funções <function>base64_encode</function> e <function>base64_decode</function>
    respectivamente.
    <literal>convert.base64-encode</literal> suporta parâmetros no formato de
    um array associativo. Se <parameter>line-length</parameter> for passado, a
    saída do base64 será dividida em pedaços de <parameter>line-length</parameter>
    caracteres cada. Se <parameter>line-break-chars</parameter> for passado, cada
    pedaço será delimitado pelos caracteres passados. Esses parâmetros dão o
    mesmo efeito que usar <function>base64_encode</function> com
    <function>chunk_split</function>.
   </simpara>
   <example>
    <title>
     convert.base64-encode &amp;
     convert.base64-decode
    </title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-encode');
fwrite($fp, "Isto é um teste.\n");
fclose($fp);
/* Saída:    SXN0byDDqSB1bSB0ZXN0ZS4K  */

$param = array('line-length' => 8, 'line-break-chars' => "\r\n");
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-encode', STREAM_FILTER_WRITE, $param);
fwrite($fp, "Isto é um teste.\n");
fclose($fp);
/* Saída  :  SXN0byDD
          :  qSB1bSB0
          :  ZXN0ZS4K  */

$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-decode');
fwrite($fp, "SXN0byDDqSB1bSB0ZXN0ZS4K");
fclose($fp);
/* Saída:    Isto é um teste.  */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.covert.quoted-printable">
   <title>convert.quoted-printable-encode e convert.quoted-printable-decode</title>
   <simpara>
    O uso da versão de decodificação desse filtro é equivalente ao processamento de todos os dados
    do fluxo pela função <function>quoted_printable_decode</function>.
    Não há nenhuma função equivalente a <literal>convert.quoted-printable-encode</literal>.
    <literal>convert.quoted-printable-encode</literal> suporta parâmetros passados como
    um array associativo. Além dos parâmetros suportados por
    <literal>convert.base64-encode</literal>, <literal>convert.quoted-printable-encode</literal>
    também suporta os argumentos booleanos <parameter>binary</parameter> e
    <parameter>force-encode-first</parameter>.
    <literal>convert.base64-decode</literal> suporta apenas o
    parâmetro <parameter>line-break-chars</parameter> como uma dica de tipo
    para retirar do conteúdo codificado.
   </simpara>
   <example>
    <title>
     convert.quoted-printable-encode &amp;
     convert.quoted-printable-decode
    </title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.quoted-printable-encode');
fwrite($fp, "Isto é um teste.\n");
/* Saída:    Isto =C3=A9 um teste.=0A  */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.convert.iconv">
   <title>convert.iconv.*</title>
   <simpara>
    Os filtros <literal>convert.iconv.*</literal> estarão disponíveis se
    o suporte a <link linkend="book.iconv">iconv</link> estiver habilitado, e se sua utilização é
    equivalente a processar todos os dados do fluxo através do <function>iconv</function>.
    Esses filtros não suportam parâmetros, em vez disso esperam que as codificações
    de entrada e saída sejam informados no nome do filtro, por exemplo,
    <literal>convert.iconv.&lt;input-encoding&gt;.&lt;output-encoding&gt;</literal> ou
    <literal>convert.iconv.&lt;input-encoding&gt;/&lt;output-encoding&gt;</literal>
    (ambas notações são equivalentes).
   </simpara>

   <example>
    <title>convert.iconv.*</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.iconv.utf-16le.utf-8');
fwrite($fp, "T\0h\0i\0s\0 \0i\0s\0 \0a\0 \0t\0e\0s\0t\0.\0\n\0");
fclose($fp);
/* Exibe: This is a test. */
?>
]]>
    </programlisting>
   </example>
  </section>
 </section>

 <section xml:id="filters.compression">
  <title>Filtros de Compressão</title>

  <simpara>
   Enquanto os <link linkend="wrappers.compression">Empacotadores de Compressão</link>
   fornecem uma maneira de criar
   arquivos compatíveis com gzip e bz2 no sistema de arquivos local, eles não fornecem um
   meio para compressão generalizada de fluxos de rede, nem fornecem uma
   maneira de começar com um fluxo não-comprimido e mudar para um comprimido.
   Para isso, um filtro de compressão pode ser aplicado a qualquer recurso de fluxo em qualquer momento.
  </simpara>

  <note>
   <simpara>
    Filtros de compressão <emphasis>não</emphasis> geram cabeçalhos e rodapés
    usados por utilitários de linha de comando como o <literal>gzip</literal>. Eles apenas comprimem
    e descomprimem as porções de conteúdo dos fluxos de dados comprimidos.
   </simpara>
  </note>

  <section xml:id="filters.compression.zlib">
   <title>zlib.deflate e zlib.inflate</title>
   <simpara>
    <literal>zlib.deflate</literal> (compressão) e
    <literal>zlib.inflate</literal> (descompressão) são implementações dos
    métodos de compressão descritos no <link xlink:href="&url.rfc;1951">RFC 1951</link>.
    O filtro <literal>deflate</literal> recebe até três parâmetros passados como
    um array associativo.

    <parameter>level</parameter> descreve o nível
    de compressão a ser usada (1-9). Números mais altos geralmente resultam em cargas menores com
    o custo de tempo de processamento adicional. Dois níveis especiais de compressão também existem:
    0 (para nenhuma compressão), e -1 (padrão interno da zlib -- atualmente 6).

    <parameter>window</parameter> é o logaritmo na base 2 do tamanho da janela de loopback de compressão.
    Valores mais altos (até 15 -- 32768 bytes) resultam em melhor compressão ao custo de memória,
    enquanto valores menores (até 9 -- 512 bytes) resultam em pior compressão usando menos memória.
    O tamanho padrão de <parameter>window</parameter> atualmente é <literal>15</literal>.

    <parameter>memory</parameter> é uma escala indicando quanta memória deve ser alocada para trabalhar.
    Valores válidos vão de 1 (alocação mínima) até 9 (alocação máxima). Essa alocação de memória
    afeta apenas a velocidade e não tem impacto sobre o tamanho do conteúdo gerado.
   </simpara>

   <note>
    <simpara>
     Pelo fato do nível de compressão ser o parâmetro mais usado normalmente, ele pode ser passado
     de maneira alternativa como um simples valor inteiro (ao invés de um elemento de um array).
    </simpara>
   </note>

   <simpara>
    Filtros de compressão zlib.* compression estarão disponíveis se o suporte ao
    <link linkend="ref.zlib">zlib</link> estiver ativado.
   </simpara>

   <example>
    <title>
     <literal>zlib.deflate</literal> e
     <literal>zlib.inflate</literal>
    </title>
    <programlisting role="php">
<![CDATA[
<?php
$params = array('level' => 6, 'window' => 15, 'memory' => 9);

$original_text = "Isto é um teste.\nIsto é apenas um teste.\nEsta não é uma string importante.\n";
echo "O texto original tem " . strlen($original_text) . " caracteres.\n";

$fp = fopen('test.deflated', 'w');
stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $params);
fwrite($fp, $original_text);
fclose($fp);

echo "O arquivo comprimido tem " . filesize('test.deflated') . " bytes.\n";
echo "O texto original era:\n";
/* Use readfile e zlib.inflate para descomprimir de forma improvisada */
readfile('php://filter/zlib.inflate/resource=test.deflated');

/* Gera a saída:

O texto original tem 79 caracteres.
O arquivo comprimido tem 61 bytes.
O texto original era:
Isto é um teste.
Isto é apenas um teste.
Esta não é uma string importante.

 */
?>
]]>
    </programlisting>
   </example>

   <example>
    <title>
     <literal>zlib.deflate</literal> simples
    </title>
    <programlisting role="php">
<![CDATA[
<?php
$original_text = "Isto é um teste.\nIsto é apenas um teste.\nEsta não é uma string importante.\n";
echo "O texto original tem " . strlen($original_text) . " caracteres.\n";

$fp = fopen('test.deflated', 'w');
/* Aqui "6" indica nível de compressão 6 */
stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, 6);
fwrite($fp, $original_text);
fclose($fp);

echo "O arquivo comprimido tem " . filesize('test.deflated') . " bytes.\n";

/* Gera a saída:

O texto original tem 79 caracteres.
O arquivo comprimido tem 60 bytes.

 */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.compression.bzip2">
   <title>bzip2.compress e bzip2.decompress</title>
   <simpara>
    <literal>bzip2.compress</literal> e
    <literal>bzip2.decompress</literal>
    funcionam da mesma maneira que os filtros da zlib descritos acima.

    O filtro <literal>bzip2.compress</literal> aceita até dois parâmetros passados como
    elementos de um array associativo:

    <parameter>blocks</parameter> é um valor inteiro
    de 1 até 9 especificando o número de blocos de 100kbyte de memória para alocar para
    o espaço de trabalho.

    <parameter>work</parameter> também é um valor inteiro variando de
    0 a 250 indicando quanto esforço será realizado usando o método normal de compressão
    antes de desistir e usar um mais lento, mas mais confiável. Alterar esse parâmetro
    afeta apenas a velocidade de compressão. Nem o tamanho da saída comprimida nem o uso de memória
    são alterados por essa configuração. Um fator de trabalho de 0 diz à biblioteca bzip para usar
    o padrão interno.

    O filtro <literal>bzip2.decompress</literal> só aceita um parâmetro,
    que pode ser passado ou como um valor booleano comum ou como o
    elemento <parameter>small</parameter> de um array associativo.

    <parameter>small</parameter>, quando configurado para o valor &true;, diz à biblioteca bzip
    para fazer a descompressão usando o mínimo de memória ao custo da velocidade.
   </simpara>

   <simpara>
     Filtros de compressão bzip2.* estão disponíveis se suporte a
     <link linkend="ref.bzip2">bz2</link> estiver ativado.
   </simpara>

   <example>
    <title>
     <literal>bzip2.compress</literal> e
     <literal>bzip2.decompress</literal>
    </title>
    <programlisting role="php">
<![CDATA[
<?php
$param = array('blocks' => 9, 'work' => 0);

echo "O arquivo original tem " . filesize('LICENSE') . " bytes.\n";

$fp = fopen('LICENSE.compressed', 'w');
stream_filter_append($fp, 'bzip2.compress', STREAM_FILTER_WRITE, $param);
fwrite($fp, file_get_contents('LICENSE'));
fclose($fp);

echo "O arquivo comprimido tem " . filesize('LICENSE.compressed') . " bytes.\n";

/* Gera a saída:

O arquivo original tem 3288 bytes.
O arquivo comprimido tem 1488 bytes.

 */
?>
]]>
    </programlisting>
   </example>
  </section>
  </section>

 <section xml:id="filters.encryption">
  <title>Filtros de Criptografia</title>

  <para>
    Os filtros de criptografia são especialmente úteis para criptografia de arquivo/stream.
  </para>

  <section xml:id="filters.encryption.mcrypt">
   <title>mcrypt.* e mdecrypt.*</title>
   &warn.deprecated.feature-7-1-0;

   <simpara>
    Os filtros <literal>mcrypt.*</literal> e <literal>mdecrypt.*</literal>
    fornecem criptografia e descriptografia simétricas usando libmcrypt.
    Ambos os conjuntos de filtros suportam os mesmos algoritmos disponíveis na
    <link linkend="ref.mcrypt">extensão mcrypt</link> na forma de
    <literal>mcrypt.ciphername</literal> onde <parameter>ciphername</parameter>
    é o nome da cifra como seria passado para
    <function>mcrypt_module_open</function>.
    Os cinco parâmetros de filtros a seguir também estão disponíveis:
   </simpara>

   <para>
    <table>
     <title>Parâmetros para os filtros mcrypt</title>
     <tgroup cols="4">
      <thead>
       <row>
        <entry>Parâmetro</entry>
        <entry>Obrigatório?</entry>
        <entry>Valor Padrão</entry>
        <entry>Exemplos de Valores</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry>mode</entry>
        <entry>Opcional</entry>
        <entry>cbc</entry>
        <entry>cbc, cfb, ecb, nofb, ofb, stream</entry>
       </row>
       <row>
        <entry>algorithms_dir</entry>
        <entry>Opcional</entry>
        <entry>ini_get('mcrypt.algorithms_dir')</entry>
        <entry>Localização dos módulos de algoritmos</entry>
       </row>
       <row>
        <entry>modes_dir</entry>
        <entry>Opcional</entry>
        <entry>ini_get('mcrypt.modes_dir')</entry>
        <entry>Localização dos módulos de modos</entry>
       </row>
       <row>
        <entry>iv</entry>
        <entry>Obrigatório</entry>
        <entry>N/A</entry>
        <entry>Tipicamente 8, 16 ou 32 bytes de dados binários. Depende da cifra.</entry>
       </row>
       <row>
        <entry>key</entry>
        <entry>Obrigatório</entry>
        <entry>N/A</entry>
        <entry>Tipicamente 8, 16 ou 32 bytes de dados binários. Depende da cifra.</entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>

   <example>
    <title>Criptografando/Descriptografando com Blowfish</title>
    <programlisting role="php">
<![CDATA[
<?php
// assume-se que $key foi gerada anteriormente
$iv_size = mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_CBC);
$iv = mcrypt_create_iv($iv_size, MCRYPT_DEV_URANDOM);
$fp = fopen('encrypted-file.enc', 'wb');
fwrite($fp, $iv);
$opts = array('mode'=>'cbc','iv'=>$iv, 'key'=>$key);
stream_filter_append($fp, 'mcrypt.blowfish', STREAM_FILTER_WRITE, $opts);
fwrite($fp, 'mensagem para criptografar');
fclose($fp);

// descriptografando...
$fp = fopen('encrypted-file.enc', 'rb');
$iv = fread($fp, $iv_size = mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_CBC));
$opts = array('mode'=>'cbc','iv'=>$iv, 'key'=>$key);
stream_filter_append($fp, 'mdecrypt.blowfish', STREAM_FILTER_READ, $opts);
$data = rtrim(stream_get_contents($fp)); // retira o preenchimento com null
fclose($fp);
echo $data;
?>
]]>
    </programlisting>
   </example>
   <example>
    <title>Criptografando arquivo usando CBC AES-128 com HMAC SHA256</title>
    <programlisting role="php">
<![CDATA[
<?php
AES_CBC::encryptFile($password, "plaintext.txt", "encrypted.enc");
AES_CBC::decryptFile($password, "encrypted.enc", "decrypted.txt");

class AES_CBC
{
   protected static $KEY_SIZES = array('AES-128'=>16,'AES-192'=>24,'AES-256'=>32);
   protected static function key_size() { return self::$KEY_SIZES['AES-128']; } // padrão AES-128
   public static function encryptFile($password, $input_stream, $aes_filename){
      $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC);
      $fin = fopen($input_stream, "rb");
      $fc = fopen($aes_filename, "wb+");
      if (!empty($fin) && !empty($fc)) {
         fwrite($fc, str_repeat("_", 32) ); // marcador, HMAC SHA256 será usado aqui mais tarde
         fwrite($fc, $hmac_salt = mcrypt_create_iv($iv_size, MCRYPT_DEV_URANDOM));
         fwrite($fc, $esalt = mcrypt_create_iv($iv_size, MCRYPT_DEV_URANDOM));
         fwrite($fc, $iv = mcrypt_create_iv($iv_size, MCRYPT_DEV_URANDOM));
         $ekey = hash_pbkdf2("sha256", $password, $esalt, $it=1000, self::key_size(), $raw=true);
         $opts = array('mode'=>'cbc', 'iv'=>$iv, 'key'=>$ekey);
         stream_filter_append($fc, 'mcrypt.rijndael-128', STREAM_FILTER_WRITE, $opts);
         $infilesize = 0;
         while (!feof($fin)) {
            $block = fread($fin, 8192);
            $infilesize+=strlen($block);
            fwrite($fc, $block);
         }
         $block_size = mcrypt_get_block_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC);
         $padding = $block_size - ($infilesize % $block_size); // $padding é um número de 1 a 16
         fwrite($fc, str_repeat(chr($padding), $padding) ); // realiza um preenchimento PKCS7
         fclose($fin);
         fclose($fc);
         $hmac_raw = self::calculate_hmac_after_32bytes($password, $hmac_salt, $aes_filename);
         $fc = fopen($aes_filename, "rb+");
         fwrite($fc, $hmac_raw); // sobrescreve o marcador
         fclose($fc);
      }
   }
   public static function decryptFile($password, $aes_filename, $out_stream) {
      $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC);
      $hmac_raw = file_get_contents($aes_filename, false, NULL, 0, 32);
      $hmac_salt = file_get_contents($aes_filename, false, NULL, 32, $iv_size);
      $hmac_calc = self::calculate_hmac_after_32bytes($password, $hmac_salt, $aes_filename);
      $fc = fopen($aes_filename, "rb");
      $fout = fopen($out_stream, 'wb');
      if (!empty($fout) && !empty($fc) && self::hash_equals($hmac_raw,$hmac_calc)) {
         fread($fc, 32+$iv_size); // ignora hmac e salt do sha256
         $esalt = fread($fc, $iv_size);
         $iv    = fread($fc, $iv_size);
         $ekey = hash_pbkdf2("sha256", $password, $esalt, $it=1000, self::key_size(), $raw=true);
         $opts = array('mode'=>'cbc', 'iv'=>$iv, 'key'=>$ekey);
         stream_filter_append($fc, 'mdecrypt.rijndael-128', STREAM_FILTER_READ, $opts);
         while (!feof($fc)) {
            $block = fread($fc, 8192);
            if (feof($fc)) {
               $padding = ord($block[strlen($block) - 1]); // assume preenchimento PKCS7
               $block = substr($block, 0, 0-$padding);
            }
            fwrite($fout, $block);
         }
         fclose($fout);
         fclose($fc);
      }
   }
   private static function hash_equals($str1, $str2) {
      if(strlen($str1) == strlen($str2)) {
         $res = $str1 ^ $str2;
         for($ret=0,$i = strlen($res) - 1; $i >= 0; $i--) $ret |= ord($res[$i]);
         return !$ret;
      }
      return false;
   }
   private static function calculate_hmac_after_32bytes($password, $hsalt, $filename) {
      static $init=0;
      $init or $init = stream_filter_register("user-filter.skipfirst32bytes", "FileSkip32Bytes");
      $stream = 'php://filter/read=user-filter.skipfirst32bytes/resource=' . $filename;
      $hkey = hash_pbkdf2("sha256", $password, $hsalt, $iterations=1000, 24, $raw=true);
      return hash_hmac_file('sha256', $stream, $hkey, $raw=true);
   }
}
class FileSkip32Bytes extends php_user_filter
{
   private $skipped=0;
   function filter($in, $out, &$consumed, $closing) {
      while ($bucket = stream_bucket_make_writeable($in)) {
         $outlen = $bucket->datalen;
         if ($this->skipped<32){
            $outlen = min($bucket->datalen,32-$this->skipped);
            $bucket->data = substr($bucket->data, $outlen);
            $bucket->datalen = $bucket->datalen-$outlen;
            $this->skipped+=$outlen;
         }
         $consumed += $outlen;
         stream_bucket_append($out, $bucket);
      }
      return PSFS_PASS_ON;
   }
}
class AES_128_CBC extends AES_CBC {
   protected static function key_size() { return self::$KEY_SIZES['AES-128']; }
}
class AES_192_CBC extends AES_CBC {
   protected static function key_size() { return self::$KEY_SIZES['AES-192']; }
}
class AES_256_CBC extends AES_CBC {
   protected static function key_size() { return self::$KEY_SIZES['AES-256']; }
}
]]>
    </programlisting>
   </example>
  </section>
 </section>

</appendix>

<!-- 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
-->