archived-doc-fr/appendices/filters.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 3f1dbc451b313fb1ec8058f24c1beccf55fce316 Maintainer: yannick Status: ready -->
<!-- Reviewed: no -->
<appendix xml:id="filters" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
 <title>Liste des filtres standards</title>
 <para>
  Cette section contient la liste des filtres de flux, à utiliser
  avec <function>stream_filter_append</function>.
  La version de PHP installée peut avoir des filtres supplémentaires,
  ou manquants par rapport à cette liste.
 </para>

 <para>
  Il est bon de noter une légère différence entre
  <function>stream_filter_append</function>
  et <function>stream_filter_prepend</function>.
  Tous les flux PHP disposent d'un petit <emphasis>buffer de lecture</emphasis>,
  où ils stockent des blocs de données lues dans le système
  de fichiers, ou dans d'autres sources, afin de les
  traiter plus efficacement. Aussitôt que les données sont
  lues depuis la ressource dans le buffer interne, les données
  sont immédiatement passées au filtre, même si l'application
  PHP n'est pas prête pour lire ces données.
  Si des données sont déjà en attente dans le buffer lorsqu'un
  filtre est ajouté au flux (<emphasis>appended</emphasis>), ces données
  seront immédiatement passées au filtre, pour que la modification soit
  transparente. Mais si l'on ajoute un filtre avec
  <emphasis>prepended</emphasis>, les données
  <emphasis>NE seront PAS</emphasis> filtrées. Elles
  attendront que le prochain bloc arrive de la ressource.
 </para>

 <para>
  Pour avoir la liste complète des filtres de la version de
  PHP installée, utiliser la fonction <function>stream_get_filters</function>.
 </para>

 <section xml:id="filters.string">
  <title>Filtres de chaînes de caractères</title>

  <simpara>
   Chaque filtre fait ce que son nom implique, et se réfère au
   comportement de la fonction PHP correspondante. Pour plus de
   détails sur un filtre, se reporter au manuel de la fonction
   de référence.
  </simpara>

  <section xml:id="filters.string.rot13">
   <title>string.rot13</title>
   <simpara>
    L'utilisation de ce filtre est équivalente à traiter toutes les données
    du flux à travers la fonction <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, "Ceci est un test.\n");
/* affiche :  Prpv rfg ha grfg.   */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.toupper">
   <title>string.toupper</title>
   <simpara>
    L'utilisation de ce filtre est équivalente à traiter toutes les données
    du flux à travers la fonction <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, "Ceci est un test.\n");
/* affiche :  CECI EST UN TEST.   */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.tolower">
   <title>string.tolower</title>
   <simpara>
    L'utilisation de ce filtre est équivalente à traiter toutes les données
    du flux à travers la fonction <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, "Ceci est un test.\n");
/* affiche :  ceci est un test.   */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.strip_tags">
   <title>string.strip_tags</title>
   <simpara>
    L'utilisation de ce filtre est équivalente à traiter toutes les données
    du flux à travers la fonction <function>strip_tags</function>.
    Le filtre accepte des paramètres sous deux formats :
    Soit comme une &string; contenant une liste de balises, similaire au
    second paramètre de la fonction <function>strip_tags</function>,
    soit en tant qu'un &array; de noms de balises.
   </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>Ce texte en gras</b> finit par être agrandi <h1>en un titre 1</h1>\n");
fclose($fp);
/* affiche :  Ce texte en gras finit par être agrandi en un titre 1   */

$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.strip_tags', STREAM_FILTER_WRITE, array('b','i','u'));
fwrite($fp, "<b>Ce texte en gras</b> finit par être agrandi <h1>en un titre 1</h1>\n");
fclose($fp);
/* affiche :  Ce texte en gras finit par être agrandi en un titre 1   */
?>
]]>
    </programlisting>
   </example>
  </section>
 </section>

 <section xml:id="filters.convert">
  <title>Filtres de conversion</title>

  <simpara>
   Comme pour les filtres de &string;, les filtres de conversion
   font ce que leur nom indique.
   Pour plus d'informations sur un filtre donné, se référer à la page du
   manuel de la fonction correspondante.
  </simpara>

  <section xml:id="filters.convert.base64">
   <title>convert.base64-encode et convert.base64-decode</title>
   <simpara>
    L'utilisation de ce filtre est équivalente à traiter toutes les données
    du flux à travers les fonctions <function>base64_encode</function> et
    <function>base64_decode</function> respectivement.
    <literal>convert.base64-encode</literal> supporte les paramètres sous forme
    de &array; associatif. Si <parameter>line-length</parameter> est fourni,
    la sortie base64 sera séparée en lignes de <parameter>line-length</parameter>
    caractères. Si <parameter>line-break-chars</parameter> est fourni, chaque
    bloc de caractères sera délimité par le caractère fourni. Ces paramètres
    donnent le même effet que la fonction <function>base64_encode</function>
    utilisée conjointement avec <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, "This is a test.\n");
fclose($fp);
/* affiche :  VGhpcyBpcyBhIHRlc3QuCg==  */

$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, "This is a test.\n");
fclose($fp);
/* affiche :  VGhpcyBp
           :  cyBhIHRl
           :  c3QuCg==  */

$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-decode');
fwrite($fp, "VGhpcyBpcyBhIHRlc3QuCg==");
fclose($fp);
/* affiche :  This is a test.  */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.covert.quoted-printable">
   <title>convert.quoted-printable-encode et convert.quoted-printable-decode</title>
   <simpara>
    L'utilisation de la version decode de ce filtre est équivalente à traiter toutes
    les données du flux à travers la fonction
    <function>quoted_printable_decode</function>. Il n'y a pas d'équivalent
    fonctionnel à <literal>convert.quoted-printable-encode</literal>.
   <literal>convert.quoted-printable-encode</literal> supporte les paramètres
    sous forme de &array; associatif. En plus des paramètres supportés par
   <literal>convert.base64-encode</literal>, <literal>convert.quoted-printable-encode</literal>
    accepte aussi les arguments &boolean; <parameter>binary</parameter> et
    <parameter>force-encode-first</parameter>.
    <literal>convert.base64-decode</literal> supporte uniquement le paramètre
    <parameter>line-break-chars</parameter> en tant qu'indicateur de type pour
    l'extraction de la charge codée.
   </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, "This is a test.\n");
/* affiche :  =This is a test.=0A  */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.convert.iconv">
   <title>convert.iconv.*</title>
   <simpara>
    Les filtres <literal>convert.iconv.*</literal> sont disponibles, si le support
    de <link linkend="book.iconv">iconv</link> est activé, et leurs usages sont
    équivalents à traiter toutes les données du flux avec <function>iconv</function>.
    Ces filtres ne supportent pas de paramètres, mais s'attendent à la place à ce que
    le nom du filtre contienne l'encodage des données en saisie et de sortie, c.-à-d.
    <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>
    (les deux notations sont sémantiquement équivalentes).
   </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);
/* Affiche : This is a test. */
?>
]]>
    </programlisting>
   </example>
  </section>
 </section>

 <section xml:id="filters.compression">
  <title>Filtres de compression</title>

  <simpara>
   Alors que les <link linkend="wrappers.compression">enveloppes de
   compression</link>  fournissent un moyen pour générer des fichiers aux
   formats gzip et bz2, ils ne permettent pas de gérer les protocoles réseaux
   compressés, ni de commencer avec un flux non compressé pour le transformer
   en flux compressé. Pour cela, un filtre de compression peut être appliqué
   à tout moment sur n'importe quelle ressource de flux.
  </simpara>

  <note>
   <simpara>
    Les filtres de compression <emphasis>ne génèrent pas</emphasis> les en-têtes
    et fins de fichiers, comme le fait l'utilitaire <literal>gzip</literal>.
    Ils ne font que compresser et décompresser des portions de flux de données.
   </simpara>
  </note>

  <section xml:id="filters.compression.zlib">
   <title>zlib.deflate et zlib.inflate</title>
   <simpara>
    <literal>zlib.deflate</literal> (compression) et
    <literal>zlib.inflate</literal> (décompression) sont les implémentations
    des méthodes de compression présentées dans la
    <link xlink:href="&url.rfc;1951">RFC 1951</link>.
    Le filtre <literal>deflate</literal> prend jusqu'à trois paramètres, passés
    sous la forme de &array; associatif.

    <parameter>level</parameter> spécifie le niveau de compression souhaité,
    de 1 à 9. Plus le niveau est haut, meilleure est la compression, et plus
    cher est le coût de compression. Deux niveaux de compression spéciaux
    existent : 0, qui représente l'absence de compression, et -1, qui
    représente le niveau par défaut de zlib : actuellement, 6.

    <parameter>window</parameter> est la taille du tampon mémoire, en base 2.
    Les valeurs supérieures, jusqu'à 15, soit 32768 octets, donnent de meilleures
    compressions, et les valeurs inférieures, jusqu'à 9, soit 512 octets,
    occupent le moins d'espace en mémoire. Par défaut,
    <parameter>window</parameter> vaut actuellement <literal>15</literal>.

    <parameter>memory</parameter> est une indication du niveau de mémoire
    nécessaire.
    Les valeurs valides vont de 1, pour l'allocation minimale, à 9, pour une
    allocation maximale. L'allocation de mémoire affecte la vitesse d'exécution,
    et n'a pas d'impact sur la taille de la charge utile générée.
   </simpara>

   <note>
    <simpara>
     Comme le niveau de compression est le paramètre le plus courant, il peut
     aussi être fourni en tant que valeur &integer;, au lieu d'un &array;.
    </simpara>
   </note>

   <simpara>
    Les filtres de compression zlib.* sont disponibles si le support de
    <link linkend="ref.zlib">zlib</link> est activé.
   </simpara>

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

$original_text = "This is a test.\nThis is only a test.\nThis is not an important string.\n";
echo "Le texte original est long de " . strlen($original_text) . " octets.\n";

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

echo "Le fichier compressé fait " . filesize('test.deflated') . " octets de long.\n";
echo "Le texte original était :\n";
/* Utilise readfile et zlib.inflate pour décompresser à la volée */
readfile('php://filter/zlib.inflate/resource=test.deflated');

/* Affiche :

Le texte original est long de 70 octets
Le fichier compressé fait 56 octets de long.
Le texte original était :
This is a test.
This is only a test.
This is not an important string.

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

   <example>
    <title>
     <literal>zlib.deflate</literal> simple
    </title>
    <programlisting role="php">
<![CDATA[
<?php
$original_text = "This is a test.\nThis is only a test.\nThis is not an important string.\n";
echo "Le texte original est long de " . strlen($original_text) . " octets.\n";

$fp = fopen('test.deflated', 'w');
/* Ici, "6" indique le niveau de compression de 6 */
stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, 6);
fwrite($fp, $original_text);
fclose($fp);

echo "Le fichier compressé fait " . filesize('test.deflated') . " octets de long.\n";

/* Affiche :

Le texte original est long de 70 octets
Le fichier compressé fait 56 octets de long.

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

  <section xml:id="filters.compression.bzip2">
   <title>bzip2.compress et bzip2.decompress</title>
   <simpara>
    <literal>bzip2.compress</literal> et
    <literal>bzip2.decompress</literal>
    fonctionnent de la même manière que les filtres zlib décrits ci-dessus.
    Le filtre <literal>bzip2.compress</literal> accepte jusqu'à 2 paramètres,
    sous la forme d'un &array; associatif :

    <parameter>blocks</parameter> est une valeur &integer;, de 1 à 9,
    spécifiant le nombre de blocs de 100 kb de mémoire à allouer à l'espace de
    travail.

    <parameter>work</parameter> est aussi un &integer; dont la valeur va de
    0 à 250, et qui indique le niveau d'effort fourni avec une méthode de
    compression avant de passer à une autre méthode, plus lente. Modifier ce
    paramètre n'a qu'un effet sur la vitesse de compression. Le gain d'espace
    ou la mémoire utilisée restent les mêmes. Un niveau de 0 indique que la
    bibliothèque doit utiliser sa configuration par défaut.

    Le filtre <literal>bzip2.decompress</literal> accepte uniquement un paramètre,
    qui peut être passé sous la forme d'un &boolean;, ou en tant que l'élément
    <parameter>small</parameter> d'un &array; associatif.

    <parameter>small</parameter>, lorsque défini à &true;, indique à la
    bibliothèque bzip qu'elle doit faire une décompression en utilisant le
    moins de mémoire possible, aux dépens de la vitesse.
   </simpara>

   <simpara>
    Les filtres bzip2.* sont disponibles si le support de
    <link linkend="ref.bzip2">bz2</link> est activé.
   </simpara>

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

echo "Le fichier original fait " . filesize('LICENSE') . " octets de long.\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 "Le fichier compressé fait " . filesize('LICENSE.compressed') . " octets de long.\n";

/* Affiche :

Le fichier original fait 3288 octets de long.
Le fichier compressé fait 1488 octets de long.

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

 <section xml:id="filters.encryption">
  <title>Filtres de chiffrement</title>

  <para>
   Les filtres de chiffrement sont particulièrement utiles pour le chiffrement
   des fichiers/flux.
  </para>

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

   <simpara>
    <literal>mcrypt.*</literal> et <literal>mdecrypt.*</literal>
    fournissent un système de chiffrement symétrique utilisant libmcrypt.
    Les deux jeux de filtres supportent les mêmes algorithmes disponibles à
    l'<link linkend="ref.mcrypt">extension mcrypt</link> sous la forme
    <literal>mcrypt.ciphername</literal> où <parameter>ciphername</parameter>
    est le nom du chiffrement qui sera transmis à
    <function>mcrypt_module_open</function>.
    Les cinq paramètres suivants sont aussi disponibles :
   </simpara>

   <para>
    <table>
     <title>Paramètres des filtres mcrypt</title>
     <tgroup cols="4">
      <thead>
       <row>
        <entry>Paramètre</entry>
        <entry>Obligatoire ?</entry>
        <entry>Par défaut</entry>
        <entry>Valeurs possibles</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry>mode</entry>
        <entry>Optionnel</entry>
        <entry>cbc</entry>
        <entry>cbc, cfb, ecb, nofb, ofb, stream</entry>
       </row>
       <row>
        <entry>algorithms_dir</entry>
        <entry>Optionnel</entry>
        <entry>ini_get('mcrypt.algorithms_dir')</entry>
        <entry>Chemin vers les algorithmes de modules</entry>
       </row>
       <row>
        <entry>modes_dir</entry>
        <entry>Optionnel</entry>
        <entry>ini_get('mcrypt.modes_dir')</entry>
        <entry>Chemin vers les modes de modules</entry>
       </row>
       <row>
        <entry>iv</entry>
        <entry>Obligatoire</entry>
        <entry>N/A</entry>
        <entry>Généralement 8, 16 ou 32 octets de données binaires. Dépend du chiffrement</entry>
       </row>
       <row>
        <entry>key</entry>
        <entry>Obligatoire</entry>
        <entry>N/A</entry>
        <entry>Généralement 8, 16 ou 32 octets de données binaires. Dépend du chiffrement</entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>

   <example>
    <title>Chiffrement / Déchiffrement avec Blowfish</title>
    <programlisting role="php">
<![CDATA[
<?php
//$key supposé être précédemment généré
$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, 'message to encrypt');
fclose($fp);

//déchiffrement...
$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));//supprime le remplissage nul
fclose($fp);
echo $data;
?>
]]>
    </programlisting>
   </example>
   <example>
    <title>Chiffrer un fichier en utilisant AES-128 CBC avec SHA256 HMAC</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']; } //default 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) );//placeholder, SHA256 HMAC will go here later
         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 is a number from 1-16
         fwrite($fc, str_repeat(chr($padding), $padding) );//perform PKCS7 padding
         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);//overwrite placeholder
         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);//skip sha256 hmac and salt
         $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 PKCS7 padding
               $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
-->