filters.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: da4977f316e4a05be800e865b979c10d19436112 Maintainer: nilgun Status: ready -->
<appendix xml:id="filters" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
 <title>Kullanılabilir Süzgeçlerin Listesi</title>
 <para>
  Burada, <function>stream_filter_append</function> işlevi ile kullanmak için
  birkaç yerleşik akım süzgecinden oluşan bir liste yer almaktadır. Kurulu
  PHP sürümünüz burada yer alan süzgeçlerden daha fazla (veya daha az)
  süzgece sahip olabilir.
 </para>

 <para>
  <function>stream_filter_append</function>
  ve <function>stream_filter_prepend</function> işlevleri arasındaki hafif
  bakışımsızlık oluşu dikkat çekicidir. Her PHP akımı, veriyi daha verimli
  bir şekilde işlemek amacıyla dosya sisteminden veya başka kaynaklardan
  aldığı veri bloklarını saklamak için küçük bir <emphasis>okuma
  tamponu</emphasis> içerir. Veri, kaynağından akımın dahili tamponuna
  çekilir çekilmez PHP uygulamasının veriyi okuyup okumayacağına bağlı olarak
  ekli süzgeçler üzerinden işleme sokulur. Veri okuma tamponundayken bir
  süzgeç verinin ardına <emphasis>eklendiği</emphasis> anda, veri sanki
  doğrudan tampondan çekiliyormuş gibi gösterilerek bu süzgeç tarafından
  işlenmeye başlanır. Bununla birlikte, eğer süzgeç tampondaki verinin ardına
  değil de <emphasis>önüne eklenirse</emphasis> tampondaki veri süzgeç
  tarafından <emphasis>işlenmez</emphasis>. Bunun yerine kaynaktan verinin
  sonraki bloğunun gelmesini bekler.
 </para>

 <para>
  Kurulu PHP sürümünüzde bulunan süzgeçlerin bir listesini
  <function>stream_get_filters</function> işlevi ile alabilirsiniz.
 </para>

 <section xml:id="filters.string">
  <title>Dizge Süzgeçleri</title>

  <simpara>
    Bu süzgeçlerin her biri tam olarak isminde yazan işlemi yaparlar ve
    karşılığı olan yerleşik PHP dizge işleme işlevinin davranışını
    sergilerler. Belli bir süzgeçle ilgili ayrıntılı bilgi edinmek için
    ilgili işlevin kılavuz sayfasına bakınız.
  </simpara>

  <section xml:id="filters.string.rot13">
   <title>string.rot13</title>
   <simpara>
    Bu süzgecin kullanımı, tüm akım verisinin
    <function>str_rot13</function> işlevi ile işlenmesine eşdeğerdir.
   </simpara>
   <example>
    <title>- <code>string.rot13</code> örneği</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.rot13');
fwrite($fp, "Bu bir denemedir.\n");
/* Çıktısı:  Oh ove qrarzrqve.  */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.toupper">
   <title>string.toupper</title>
   <simpara>
    Bu süzgecin kullanımı, tüm akım verisinin
    <function>strtoupper</function> işlevi ile işlenmesine eşdeğerdir.
   </simpara>
   <example>
    <title>- <code>string.toupper</code> örneği</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.toupper');
fwrite($fp, "Bu küçük bir denemedir.\n");
/* Çıktısı:  BU KüçüK BIR DENEMEDIR.   */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.tolower">
   <title>string.tolower</title>
   <simpara>
    Bu süzgecin kullanımı, tüm akım verisinin
    <function>strtolower</function> işlevi ile işlenmesine eşdeğerdir.
   </simpara>
   <example>
    <title>- <code>string.tolower</code> örneği</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.tolower');
fwrite($fp, "Bu küçük bir denemedir.\n");
/* Çıktısı:  bu küçük bir denemedir..   */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.string.strip_tags">
   <title>string.strip_tags</title>
   <simpara>
    (PHP 5.0.0 ve sonrası). Bu süzgecin kullanımı, tüm akım verisinin
    <function>strip_tags</function> işlevi ile işlenmesine eşdeğerdir.
    Bağımsız değişken olarak şu iki biçimden birini kabul eder: Ya
    <function>strip_tags</function> işlevinin ikinci bağımsız değişkenindeki gibi
    bir etiket listesi içeren bir dizi ya da etiket isimlerinden oluşan bir
    dizi.
   </simpara>
   <para>
    &warn.deprecated.feature-7-3-0;
   </para>
   <example>
    <title>- <code>string.strip_tags</code> örneği</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>kalın metin</b> <h1>1. seviyeden bir başlık</h1> haline getirilir\n");
fclose($fp);
/* Çıktısı: kalın metin 1. seviyeden bir başlık haline getirilir */

$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.strip_tags', STREAM_FILTER_WRITE, array('b','i','u'));
fwrite($fp, "<b>kalın metin</b> <h1>1. seviyeden bir başlık</h1> haline getirilir\n");
fclose($fp);
/* Çıktısı: kalın metin 1. seviyeden bir başlık haline getirilir */
?>
]]>
    </programlisting>
   </example>
  </section>
</section>

 <section xml:id="filters.convert">
  <title>Dönüşüm Süzgeçleri</title>

  <simpara>
   <literal>string.*</literal> süzgeçleri gibi, the
   <literal>convert.*</literal> süzgeçleri de isimlerinde yazan eylemleri
   gerçekleştirirler. Belli bir süzgeçle ilgili ayrıntılı bilgi edinmek için
   ilgili işlevin kılavuz sayfasına bakınız.
  </simpara>

  <section xml:id="filters.convert.base64">
   <title>convert.base64-encode ve convert.base64-decode</title>
   <simpara>
    Bu süzgeçlerin kullanımı, tüm
    akım verisinin sırasıyla <function>base64_encode</function> veya
    <function>base64_decode</function> işlevi ile işlenmesine eşdeğerdir.
    <literal>convert.base64-encode</literal> süzgeci bağımsız değişkenlerin bir
    ilişkisel dizi olarak belirtilmesini destekler.
    Eğer <parameter>line-length</parameter> bağımsız değişkeni verilmişse base64
    çıktı, her biri <parameter>line-length</parameter> baytlık parçalara
    bölünür. Eğer <parameter>line-break-chars</parameter> bağımsız değişkeni
    verilmişse çıktının her parçası belirtilen karakterle sınırlanır. Bu
    bağımsız değişkenler <function>base64_encode</function> işlevinin
    <function>chunk_split</function> ile birlikte kullanımına eşdeğer bir
    etkiye sebep olur.
   </simpara>
   <example>
    <title>- <code>convert.base64-encode</code> ve
     <code>convert.base64-decode</code> örneği</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-encode');
fwrite($fp, "Bu bir denemedir.\n");
echo "\n";
fclose($fp);
/* Çıktısı:  QnUgYmlyIGRlbmVtZWRpci4K */

$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, "Bu bir denemedir.\n");
echo "\n";
fclose($fp);
/* Çıktısı:   QnUgYmly
          :   IGRlbmVt
          :   ZWRpci4K   */

$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-decode');
fwrite($fp, "QnUgYmlyIGRlbmVtZWRpci4K");
echo "\n";
fclose($fp);
/* Çıktısı:  Bu bir denemedir.  */
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.covert.quoted-printable">
   <title>convert.quoted-printable-encode ve convert.quoted-printable-decode</title>
   <simpara>
    Bu süzgeçlerden kod
    çözme (decode) ile ilgili olanın kullanımı, tüm akım verisinin
    <function>quoted_printable_decode</function> işlevi ile işlenmesine
    eşdeğerdir. <literal>convert.quoted-printable-encode</literal> işlevine
    eşdeğer bir süzgeç yoktur.
    <literal>convert.quoted-printable-encode</literal> süzgeci
    bağımsız değişkenlerinin bir ilişkisel dizi olarak verilmesini destekler.
    <literal>convert.base64-encode</literal> süzgecinin bağımsız değişkenlerine ek
    olarak, <parameter>binary</parameter> ve
    <parameter>force-encode-first</parameter> bağımsız değişkenlerini de destekler.
    <literal>convert.quoted-printable-encode</literal> süzgeci, kodlanmış
    veriden yararlı yükü ayırmak için bir ipucu olarak sadece
    <parameter>line-break-chars</parameter> bağımsız değişkenini destekler.
   </simpara>
   <example>
    <title>- <code>convert.quoted-printable-encode</code> ve
     <code>convert.quoted-printable-decode</code> örneği</title>
    <programlisting role="php">
<![CDATA[
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.quoted-printable-encode');
fwrite($fp, "Bu küçük bir denemedir.\n");
/* Çıktısı:  Bu k=C3=BC=C3=A7=C3=BCk bir denemedir.=0A  */

$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.quoted-printable-decode');
fwrite($fp, "Bu k=C3=BC=C3=A7=C3=BCk bir denemedir.=0A");
/* Çıktısı:  Bu küçük bir denemedir.
*/
?>
]]>
    </programlisting>
   </example>
  </section>

  <section xml:id="filters.convert.iconv">
   <title>convert.iconv.*</title>
   <simpara>
    <literal>convert.iconv.*</literal> süzgeçleri
    <link linkend="book.iconv">iconv</link> desteği etkinse kullanılabilir
    olup tüm akım verisinin <function>iconv</function> ile işlenmesine
    eşdeğerdir. Bu süzgeçler bağımsız değişkenleri desteklememekle beraber girdi ve
    çıktı kodlamaları süzgeç isminin parçası olarak verilebilir. Örneğin,
    <literal>convert.iconv.&lt;input-encoding&gt;.&lt;output-encoding&gt;</literal> veya
    <literal>convert.iconv.&lt;input-encoding&gt;/&lt;output-encoding&gt;</literal>
    (her iki gösterim anlamsal olarak eşdeğerdir).
   </simpara>

   <example>
    <title>- <code>convert.iconv.*</code> örneği</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);
/* Çıktısı: This is a test. */
?>
]]>
    </programlisting>
   </example>
  </section>
 </section>

 <section xml:id="filters.compression">
  <title>Sıkıştırma Süzgeçleri</title>

  <simpara>
    <link linkend="wrappers.compression">Sıkıştırma Sarmalayıcıları</link>
    yerel dosya sisteminde <literal>gzip</literal> ve <literal>bz2</literal>
    uyumlu dosyalar oluşturabilmelerine rağmen ne ağ akımlarına sıkıştırma
    uygulayabilir ne de sıkıştırılmış ağ akımlarının sıkıştırmasını
    açabilirler. Bunu sağlamak için, akım kaynaklarına herhangi bir anda bir
    sıkıştırma süzgeci uygulanabilir.
  </simpara>

  <note>
   <simpara>
    Sıkıştırma süzgeçleri <code>gzip</code> gibi komut satırı uygulamaları
    tarafından kullanılan dosya baş uç ve ayak uçlarını
    <emphasis>üretmezler</emphasis>. Sadece
    sıkıştırılmış veri akımlarının yararlı yükünü sıkıştırıp açarlar.
   </simpara>
  </note>

  <section xml:id="filters.compression.zlib">
   <title>zlib.deflate and zlib.inflate</title>
   <simpara>
    <link xlink:href="&url.rfc;1951">RFC 1951</link>'de tanımlanan sıkıştırma
    yöntemlerini gerçekler. <literal>deflate</literal> (sıkıştırma) süzgeci,
    aktarılan üç bağımsız değişkeni bir ilişkisel dizi olarak kabul eder.

    <parameter>level</parameter> bağımsız değişkeni sıkıştırmanın derecesini (1-9)
    belirler. Büyük numaralar, küçüklerine göre genelde daha küçük yararlı yük
    oluşturmasına rağmen daha uzun işlem zamanına gerektirirler. Ayrıca iki
    özel sıkıştırma seviyesi daha mevcuttur: 0 (hiç sıkıştırma yapılmaz) ve -1
    (zlib yerleşik öntanımlısı; şimdilik 6).

    <parameter>window</parameter> bağımsız değişkeninin değeri, sıkıştırma döngüsü
    pencere genişliğinin 2 tabanına göre logaritmasıdır. Yüksek değerler
    (yukarda 15'e -- 32768 bayta kadar) daha büyük bellek tüketimi
    karşılığında daha çok sıkıştırma sağlarken, düşük değerler (aşağıda 9'a --
    512 bayta kadar) daha az bellek tüketimi karşılığında daha az sıkıştırma
    sağlar. Öntanımlı  <parameter>window</parameter> genişliği şimdilik
    <constant>15</constant>'tir.

    <parameter>memory</parameter> bağımsız değişkeninin değeri ne kadar bellek
    ayrılacağını belirleyen bir katsayıdır. Geçerli değerler 1'den (en az
    bellek ayırma) 9'a (en çok bellek ayırma) kadardır. Bu bellek ayırma
    işlemi sadece hızı etkiler, üretilen yararlı yükün boyutuna etkisi yoktur.
   </simpara>

   <note>
    <simpara>
     Sıkıştırma seviyesi en çok kullanılan bağımsız değişken olduğundan bir dizi
     elemanı olarak belirtilebildiği gibi tek başına basit bir bağımsız değişken
     olarak da  belirtilebilmektedir.
    </simpara>
   </note>

   <simpara>
    <literal>zlib.*</literal> sıkıştırma süzgeçleri,  <link
    linkend="ref.zlib">zlib</link> desteği etkin olduğu takdirde
    kullanılabilmektedir.
   </simpara>

   <example>
    <title>- <code>zlib.deflate</code> ve <code>zlib.inflate</code> örneği
    </title>
    <programlisting role="php">
<![CDATA[
<?php
$params = array('level' => 6, 'window' => 15, 'memory' => 9);

$özgün_metin = "Bu bir denemedir.\nBu sadece bir denemedir.\nBu önemli bir dizge değildir.\n";
echo "Özgün metin " . strlen($özgün_metin) . " karakter uzunluktadır.\n";

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

echo "Sıkıştırılmış dosya ".filesize('test.deflated')." bayt uzunluktadır.\n";
echo "Özgün metin:\n";
/* veriyi bir yere aktarmadan sıkıştırmayı açmak için
   readfile ve zlib.inflate kullanalım  */
readfile('php://filter/zlib.inflate/resource=test.deflated');

/* Üretilen çıktı:

Özgün metin 75 karakter uzunluktadır.
Sıkıştırılmış dosya 57 bayt uzunluktadır.
Özgün metin:
Bu bir denemedir.
Bu sadece bir denemedir.
Bu önemli bir dizge değildir.
 */

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

   <example>
    <title>- Basit bir <code>zlib.deflate</code> örneği</title>
    <programlisting role="php">
<![CDATA[
<?php
$özgün_metin = "Bu bir denemedir.\nBu sadece bir denemedir.\nBu önemsiz bir dizgedir.\n";
echo "Özgün metin ".strlen($özgün_metin)." karakter uzunluktadır.\n";

$fp = fopen('test.deflated', 'w');
/* Buradaki "6" sıkıştırma seviyesinin 6 olduğunu göstermektedir */
stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, 6);
fwrite($fp, $özgün_metin);
fclose($fp);

echo "Sıkıştırılmış dosya ".filesize('test.deflated')." bayt uzunluktadır.\n";

/* Üretilen çıktı:

Özgün metin 69 karakter uzunluktadır.
Sıkıştırılmış dosya 45 bayt uzunluktadır.

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

  <section xml:id="filters.compression.bzip2">
   <title>bzip2.compress and bzip2.decompress</title>
   <simpara>
    <literal>bzip2.compress</literal> ve <literal>bzip2.decompress</literal>
    süzgeçleri yukarıda açıklanan <literal>zlib</literal> süzgeçleriyle aynı
    anlamda çalışırlar.

    <literal>bzip2.compress</literal> süzgeci bir ilişkisel dizinin elemanları
    olarak iki bağımsız değişken kabul eder:

    <parameter>blocks</parameter> bağımsız değişkeni, çalışma alanı için ayrılacak
    belleğin 100 kbaytlık katları olarak 1'den 9'a kadar bir tamsayıdır.

    <parameter>work</parameter> bağımsız değişkeni de bir tamsayı olup, son çare
    olarak daha yavaş fakat daha güvenilir bir yönteme başvurmadan önce normal
    bir sıkıştırma yöntemine ne kadar çaba harcanacağını belirten 0'dan 250'ye
    kadar bir değerdir. Bu bağımsız değişken sadece hız üzerinde etkilidir. Bu
    ayardan ne sıkıştırılmış çıktının boyu ne de bellek kullanımı etkilenir. 0
    değeri bzip kütüphanesinin yerleşik öntanımlısının kullanılacağı anlamına
    gelir.

    <literal>bzip2.decompress</literal> süzgeci tek bir bağımsız değişken kabul eder.
    Ya sıradan bir mantıksal değer ya da <parameter>small</parameter>
    anahtarlı tek elemanı olan bir ilişkisel dizidir.

    <parameter>small</parameter> bağımsız değişkenine &true; değerinin atanması,
    bzip2 kütüphanesinin sıkıştırmayı açmak için hız pahasına en az belleği
    ayıracağı anlamına gelir.
   </simpara>

   <simpara>
    <literal>bzip2.*</literal> sıkıştırma süzgeçleri, <link
    linkend="ref.bzip2">bz2</link> desteği etkin olduğu takdirde
    kullanılabilmektedir.
   </simpara>

   <example>
    <title>- <code>bzip2.compress</code> ve <code>bzip2.decompress</code>
    örneği</title>
    <programlisting role="php">
<![CDATA[
<?php
$param = array('blocks' => 9, 'work' => 0);

echo "Özgün dosya " . filesize('LICENSE') . " bayt uzunluktadır.\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 "Sıkıştırılmış dosya " . filesize('LICENSE.compressed') . " bayt uzunluktadır.\n";

/* Üretilen çıktı:

Özgün dosya 3288 bayt uzunluktadır.
Sıkıştırılmış dosya 1488 bayt uzunluktadır.

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

 <section xml:id="filters.encryption">
  <title>Şifreleme Süzgeçleri</title>
  <para>
   Şifreleme süzgeçleri öxellikle dosya/akım şifrelemesinde kullanışlıdır.
  </para>

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

   <simpara>
    <literal>mcrypt.*</literal> ve <literal>mdecrypt.*</literal> süzgeçleri
    libmcrypt kullanarak bakışımlı şifreleme ve şifre çözme yaparlar. Her iki
    süzgeç ailesi de <literal>mcrypt.şifreismi</literal> biçeminde <link
    linkend="ref.mcrypt">mcrypt eklentisinde</link> kullanılan algoritmaları
    desteklerler; buradaki <parameter>şifreismi</parameter>
    <function>mcrypt_module_open</function> işlevine aktarıldığı şekliyle
    şifrenin ismidir. Ayrıca, aşağıdaki beş süzgeç bağımsız değişkeni de
    kullanılabilmektedir:
   </simpara>

   <para>
    <table>
     <title>mcrypt süzgeç bağımsız değişkenleri</title>
     <tgroup cols="4">
      <thead>
       <row>
        <entry>Bağımsız değişken</entry>
        <entry>Gereklilik</entry>
        <entry>Öntanımlı</entry>
        <entry>Örnek değerler</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry>mode</entry>
        <entry>seçimlik</entry>
        <entry>cbc</entry>
        <entry>cbc, cfb, ecb, nofb, ofb, stream</entry>
       </row>
       <row>
        <entry>algorithms_dir</entry>
        <entry>seçimlik</entry>
        <entry>ini_get('mcrypt.algorithms_dir')</entry>
        <entry>Algoritma modüllerinin yeri</entry>
       </row>
       <row>
        <entry>modes_dir</entry>
        <entry>seçimlik</entry>
        <entry>ini_get('mcrypt.modes_dir')</entry>
        <entry>Kip modüllerinin yeri</entry>
       </row>
       <row>
        <entry>iv</entry>
        <entry>gerekli</entry>
        <entry>yok</entry>
        <entry>Genelde 8, 16 veya 32 baytlık ikil veri.  Şifreye bağlı.</entry>
       </row>
       <row>
        <entry>key</entry>
        <entry>gerekli</entry>
        <entry>yok</entry>
        <entry>Genelde 8, 16 veya 32 baytlık ikil veri.  Şifreye bağlı.</entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>

   <example>
    <title>- 3DES kullanarak şifreli dosya çıktılama</title>
    <programlisting role="php">
<![CDATA[
<?php
//$key evvelce üretilmiş varsayılıyor
$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);

//decrypt...
$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));//null dizesi temizleniyor
fclose($fp);
echo $data;
?>
]]>
    </programlisting>
   </example>
   <example>
    <title>- SHA256 HMAC ile AES-128 CBC kullanarak dosya şifreleme</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
-->