Crypto wrapper - implements tag based en/decryption

include/class.crypto.php

+<?php
+/*********************************************************************
+    class.crypto.php
+
+    Crypto wrapper - implements tag based encryption/descryption
+
+    Peter Rotich <peter@osticket.com>
+    Copyright (c)  2006-2013 osTicket
+    http://www.osticket.com
+
+    Credit:
+    https://defuse.ca/secure-php-encryption.htm
+    Interwebz
+
+    Released under the GNU General Public License WITHOUT ANY WARRANTY.
+    See LICENSE.TXT for details.
+
+    vim: expandtab sw=4 ts=4 sts=4:
+**********************************************************************/
+
+//Top level encryption  options.
+define('CRYPT_MCRYPT', 1);
+define('CRYPT_OPENSSL', 2);
+define('CRYPT_PHPSECLIB', 3);
+
+require_once PEAR_DIR.'Crypt/Hash.php';
+require_once PEAR_DIR.'Crypt/Random.php';
+
+class Crypto {
+
+
+    function encrypt($input, $key, $skey='encryption', $crypt=null) {
+
+        //Gets preffered crypto.
+        if(!($crypto =  Crypto::get($crypt)))
+            return false;
+
+        //Set master and subkeys
+        $crypto->setKeys($key, $skey);
+
+        if(!($ciphertext=$crypto->encrypt($input)))
+            return false;
+
+        return sprintf('$%d$%s', $crypto->getTagNumber(), $ciphertext);
+    }
+
+    function decrypt($ciphertext, $key, $skey='encryption') {
+
+        if(!preg_match('/^\\$(\d)\\$(.*)/', $ciphertext, $result))
+            return false;
+
+        $crypt = $result[1]; //Crypt used..
+        $ciphertext = $result[2]; //encrypted  input.
+
+        //Get crypto....  based on the tag.
+        if(!($crypto=Crypto::get($crypt)) || !$crypto->exists())
+            return false;
+
+        $crypto->setKeys($key, $skey);
+
+        return $crypto->decrypt($ciphertext);
+    }
+
+    function get($crypt) {
+
+        $cryptos = self::cryptos();
+        if(!$cryptos || ($crypt && !isset($cryptos[$crypt])))
+            return null;
+
+        //Requested crypto available??
+        if($crypt &&  $cryptos[$crypt])
+            return $cryptos[$crypt];
+
+        //cycle thro' available cryptos
+        foreach($cryptos as $crypto) {
+            if(is_callable(array($crypto, 'exists'))
+                    && call_user_func(array($crypto, 'exists')))
+                return  $crypto;
+        }
+
+        return null;
+    }
+
+    function cryptos() {
+
+        //list of available  && supported cryptos
+        $cryptos =  array();
+        if(defined('CRYPT_MCRYPT') && class_exists('CryptoMcrypt'))
+            $cryptos[CRYPT_MCRYPT] = new CryptoMcrypt(CRYPT_MCRYPT);
+
+        if(defined('CRYPT_OPENSSL') && class_exists('CryptoOpenSSL'))
+            $cryptos[CRYPT_OPENSSL] = new CryptoOpenSSL(CRYPT_OPENSSL);
+
+        if(defined('CRYPT_PHPSECLIB') && class_exists('CryptoPHPSecLib'))
+            $cryptos[CRYPT_PHPSECLIB] = new CryptoPHPSecLib(CRYPT_PHPSECLIB);
+
+        //var_dump($cryptos);
+
+        return $cryptos;
+    }
+
+    /* Hash string  - sha1 is used by default */
+    function hash($string, $key) {
+        $hash = new Crypt_Hash();
+        $hash->setKey($key);
+        return base64_encode($hash->hash($string));
+    }
+
+    /* Generates random string of @len length */
+    function randcode($len) {
+        return crypt_random_string($len);
+    }
+}
+
+class CryptoAlgo {
+
+    var $master_key;
+    var $sub_key;
+
+    var $tag_number;
+
+    function  CryptoAlgo($tag) {
+        $this->tag_number = $tag;
+    }
+
+    function getTagNumber() {
+        return $this->tag_number;
+    }
+
+    function getMasterKey() {
+        return $this->master_key;
+    }
+
+    function getSubKey() {
+        return $this->sub_key;
+    }
+
+    function setKeys($master, $sub) {
+        $this->master_key = $master;
+        $this->sub_key = $sub;
+    }
+
+    function getKeyHash($seed) {
+
+        $hash = Crypto::hash($this->getMasterKey().md5($this->getSubKey()), $seed);
+        return $seed? substr($hash, 0, strlen($seed)) : $hash;
+    }
+}
+
+define('CRYPTO_CIPHER_MCRYPT_RIJNDAEL_128', 1);
+
+Class CryptoMcrypt extends CryptoAlgo {
+
+    var $ciphers = array(
+            CRYPTO_CIPHER_MCRYPT_RIJNDAEL_128 => array(
+                'name' => MCRYPT_RIJNDAEL_128,
+                'mode' => 'cbc',
+                ),
+            );
+
+    function getCipher($id) {
+
+        return ($id && isset($this->ciphers[$id]))
+            ? $this->ciphers[$id] : null;
+    }
+
+    function encrypt($text, $cid=CRYPTO_CIPHER_MCRYPT_RIJNDAEL_128) {
+
+        if(!$this->exists() || !$text || !($cipher=$this->getCipher($cid)))
+            return false;
+
+        $td = mcrypt_module_open($cipher['name'], '', $cipher['mode'], '');
+        $keysize = mcrypt_enc_get_key_size($td);
+        $ivsize = mcrypt_enc_get_iv_size($td);
+        $iv = mcrypt_create_iv($ivsize, MCRYPT_DEV_RANDOM); //XXX: Windows??
+
+        //Add padding
+        $blocksize = mcrypt_enc_get_block_size($td);
+        $pad = $blocksize - (strlen($text) % $blocksize);
+        $text .= str_repeat(chr($pad), $pad);
+
+        // Do the encryption.
+        mcrypt_generic_init($td, $this->getKeyHash($iv), $iv);
+        $ciphertext = $iv . mcrypt_generic($td, $text);
+        mcrypt_generic_deinit($td);
+        mcrypt_module_close($td);
+
+        return sprintf('$%s$%s', $cid, $ciphertext);
+    }
+
+    function decrypt($ciphertext) {
+
+         if(!$this->exists() || !$ciphertext)
+             return false;
+
+         if(!preg_match('/^\\$(\d)\\$(.*)/', $ciphertext, $result)
+                 || !($cipher=$this->getCipher($result[1])))
+             return false;
+
+         $ciphertext = $result[2];
+
+         $td = mcrypt_module_open($cipher['name'], '', $cipher['mode'], '');
+         $keysize = mcrypt_enc_get_key_size($td);
+         $ivsize = mcrypt_enc_get_iv_size($td);
+
+         if(strlen($ciphertext) <= $ivsize)
+             return false;
+
+         $iv = substr($ciphertext, 0, $ivsize);
+         $ciphertext = substr($ciphertext, $ivsize);
+
+         // Do the decryption.
+         mcrypt_generic_init($td, $this->getKeyHash($iv), $iv);
+         $plaintext = mdecrypt_generic($td, $ciphertext);
+         mcrypt_generic_deinit($td);
+         mcrypt_module_close($td);
+
+         // Remove the padding.
+         $pad = ord($plaintext[strlen($plaintext) -1]);
+         $plaintext = substr($plaintext, 0, strlen($plaintext) - $pad);
+
+         return $plaintext;
+    }
+
+    function exists() {
+        return extension_loaded('mcrypt');
+    }
+}
+
+define('CRYPTO_CIPHER_OPENSSL_AES_128_CBC', 1);
+
+class CryptoOpenSSL extends CryptoAlgo {
+
+    var $ciphers = array(
+            CRYPTO_CIPHER_OPENSSL_AES_128_CBC => array(
+                'method' => 'aes-128-cbc',
+                ),
+            );
+
+    function getMethod($cid) {
+        return ($cid && isset($this->ciphers[$cid])) ?
+            $this->ciphers[$cid]['method'] : null;
+    }
+
+    function encrypt($text, $cid=CRYPTO_CIPHER_OPENSSL_AES_128_CBC) {
+
+        if(!$this->exists() || !$text || !($method=$this->getMethod($cid)))
+            return false;
+
+        $ivlen  = openssl_cipher_iv_length($method);
+        $iv = openssl_random_pseudo_bytes($ivlen);
+
+        if(!($ciphertext = openssl_encrypt($text, $method,
+                        $this->getKeyHash($iv), 0, $iv)))
+            return false;
+
+        return sprintf('$%s$%s%s', $cid, $iv, $ciphertext);
+    }
+
+    function decrypt($ciphertext) {
+
+
+        if(!$this->exists() || !$ciphertext)
+            return false;
+
+        if(!preg_match('/^\\$(\d)\\$(.*)/', $ciphertext, $result)
+                ||
+                !($method=$this->getMethod($result[1])))
+            return false;
+
+        $ciphertext = $result[2];
+
+        $ivlen  = openssl_cipher_iv_length($method);
+        $iv = substr($ciphertext, 0, $ivlen);
+        $ciphertext = substr($ciphertext, $ivlen);
+
+        $plaintext = openssl_decrypt($ciphertext, $method,
+                $this->getKeyHash($iv), 0, $iv);
+
+        return $plaintext;
+    }
+
+    function exists() {
+        return  extension_loaded('openssl');
+    }
+}
+
+
+require_once PEAR_DIR.'Crypt/AES.php';
+define('CRYPTO_CIPHER_PHPSECLIB_AES_CBC', 1);
+
+class CryptoPHPSecLib extends CryptoAlgo {
+    var $ciphers = array(
+            CRYPTO_CIPHER_PHPSECLIB_AES_CBC => array(
+                'mode' => CRYPT_AES_MODE_CBC,
+                'ivlen' => 16,
+                ),
+            );
+
+    function getCrypto($cid) {
+
+        if(!$cid || !isset($this->ciphers[$cid])
+                || !($cipher=$this->ciphers[$cid]))
+            return false;
+
+        $crypto = null;
+        switch($cid) {
+            case CRYPTO_CIPHER_PHPSECLIB_AES_CBC:
+                $crypto = new Crypt_AES($cipher['mode']);
+                break;
+        }
+
+        return $crypto;
+    }
+
+    function getIVLen($cid) {
+        return ($cid && !isset($this->ciphers[$cid]['ivlen'])) ?
+            $this->ciphers[$cid]['ivlen'] : 16;
+    }
+
+    function encrypt($text, $cid=CRYPTO_CIPHER_PHPSECLIB_AES_CBC) {
+
+        if(!$this->exists() || !$text || !($crypto=$this->getCrypto($cid)))
+            return false;
+
+        $iv = Crypto::randcode($this->getIVLen($cid));
+        $crypto->setKey($this->getKeyHash($iv));
+        $crypto->setIV($iv);
+
+        return sprintf('$%s$%s%s', $cid, $iv, $crypto->encrypt($text));
+    }
+
+    function decrypt($ciphertext) {
+
+        if(!$this->exists() || !$ciphertext)
+            return false;
+
+        if(!preg_match('/^\\$(\d)\\$(.*)/', $ciphertext, $result)
+                || !($crypto=$this->getCrypto($result[1])))
+            return false;
+
+        $ciphertext = $result[2];
+        $ivlen = $this->getIVLen($result[1]);
+        $iv = substr($result[2], 0, $ivlen);
+        $ciphertext = substr($result[2], $ivlen);
+        $crypto->setKey($this->getKeyHash($iv));
+        $crypto->setIV($iv);
+
+        return $crypto->decrypt($ciphertext);
+    }
+
+    function exists() {
+        return  class_exists('Crypt_AES');
+    }
+}
+?>

include/pear/Crypt/AES.php

+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Pure-PHP implementation of AES.
+ *
+ * Uses mcrypt, if available, and an internal implementation, otherwise.
+ *
+ * PHP versions 4 and 5
+ *
+ * If {@link Crypt_AES::setKeyLength() setKeyLength()} isn't called, it'll be calculated from
+ * {@link Crypt_AES::setKey() setKey()}.  ie. if the key is 128-bits, the key length will be 128-bits.  If it's 136-bits
+ * it'll be null-padded to 160-bits and 160 bits will be the key length until {@link Crypt_Rijndael::setKey() setKey()}
+ * is called, again, at which point, it'll be recalculated.
+ *
+ * Since Crypt_AES extends Crypt_Rijndael, some functions are available to be called that, in the context of AES, don't
+ * make a whole lot of sense.  {@link Crypt_AES::setBlockLength() setBlockLength()}, for instance.  Calling that function,
+ * however possible, won't do anything (AES has a fixed block length whereas Rijndael has a variable one).
+ *
+ * Here's a short example of how to use this library:
+ * <code>
+ * <?php
+ *    include('Crypt/AES.php');
+ *
+ *    $aes = new Crypt_AES();
+ *
+ *    $aes->setKey('abcdefghijklmnop');
+ *
+ *    $size = 10 * 1024;
+ *    $plaintext = '';
+ *    for ($i = 0; $i < $size; $i++) {
+ *        $plaintext.= 'a';
+ *    }
+ *
+ *    echo $aes->decrypt($aes->encrypt($plaintext));
+ * ?>
+ * </code>
+ *
+ * LICENSE: Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @category   Crypt
+ * @package    Crypt_AES
+ * @author     Jim Wigginton <terrafrost@php.net>
+ * @copyright  MMVIII Jim Wigginton
+ * @license    http://www.opensource.org/licenses/mit-license.html  MIT License
+ * @link       http://phpseclib.sourceforge.net
+ */
+
+/**
+ * Include Crypt_Rijndael
+ */
+if (!class_exists('Crypt_Rijndael')) {
+    require_once 'Rijndael.php';
+}
+
+/**#@+
+ * @access public
+ * @see Crypt_AES::encrypt()
+ * @see Crypt_AES::decrypt()
+ */
+/**
+ * Encrypt / decrypt using the Counter mode.
+ *
+ * Set to -1 since that's what Crypt/Random.php uses to index the CTR mode.
+ *
+ * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Counter_.28CTR.29
+ */
+define('CRYPT_AES_MODE_CTR', -1);
+/**
+ * Encrypt / decrypt using the Electronic Code Book mode.
+ *
+ * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Electronic_codebook_.28ECB.29
+ */
+define('CRYPT_AES_MODE_ECB', 1);
+/**
+ * Encrypt / decrypt using the Code Book Chaining mode.
+ *
+ * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher-block_chaining_.28CBC.29
+ */
+define('CRYPT_AES_MODE_CBC', 2);
+/**
+ * Encrypt / decrypt using the Cipher Feedback mode.
+ *
+ * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher_feedback_.28CFB.29
+ */
+define('CRYPT_AES_MODE_CFB', 3);
+/**
+ * Encrypt / decrypt using the Cipher Feedback mode.
+ *
+ * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Output_feedback_.28OFB.29
+ */
+define('CRYPT_AES_MODE_OFB', 4);
+/**#@-*/
+
+/**#@+
+ * @access private
+ * @see Crypt_AES::Crypt_AES()
+ */
+/**
+ * Toggles the internal implementation
+ */
+define('CRYPT_AES_MODE_INTERNAL', 1);
+/**
+ * Toggles the mcrypt implementation
+ */
+define('CRYPT_AES_MODE_MCRYPT', 2);
+/**#@-*/
+
+/**
+ * Pure-PHP implementation of AES.
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ * @version 0.1.0
+ * @access  public
+ * @package Crypt_AES
+ */
+class Crypt_AES extends Crypt_Rijndael {
+    /**
+     * mcrypt resource for encryption
+     *
+     * The mcrypt resource can be recreated every time something needs to be created or it can be created just once.
+     * Since mcrypt operates in continuous mode, by default, it'll need to be recreated when in non-continuous mode.
+     *
+     * @see Crypt_AES::encrypt()
+     * @var String
+     * @access private
+     */
+    var $enmcrypt;
+
+    /**
+     * mcrypt resource for decryption
+     *
+     * The mcrypt resource can be recreated every time something needs to be created or it can be created just once.
+     * Since mcrypt operates in continuous mode, by default, it'll need to be recreated when in non-continuous mode.
+     *
+     * @see Crypt_AES::decrypt()
+     * @var String
+     * @access private
+     */
+    var $demcrypt;
+
+    /**
+     * mcrypt resource for CFB mode
+     *
+     * @see Crypt_AES::encrypt()
+     * @see Crypt_AES::decrypt()
+     * @var String
+     * @access private
+     */
+    var $ecb;
+
+    /**
+     * Default Constructor.
+     *
+     * Determines whether or not the mcrypt extension should be used.  $mode should only, at present, be
+     * CRYPT_AES_MODE_ECB or CRYPT_AES_MODE_CBC.  If not explictly set, CRYPT_AES_MODE_CBC will be used.
+     *
+     * @param optional Integer $mode
+     * @return Crypt_AES
+     * @access public
+     */
+    function Crypt_AES($mode = CRYPT_AES_MODE_CBC)
+    {
+        if ( !defined('CRYPT_AES_MODE') ) {
+            switch (true) {
+                case extension_loaded('mcrypt') && in_array('rijndael-128', mcrypt_list_algorithms()):
+                    define('CRYPT_AES_MODE', CRYPT_AES_MODE_MCRYPT);
+                    break;
+                default:
+                    define('CRYPT_AES_MODE', CRYPT_AES_MODE_INTERNAL);
+            }
+        }
+
+        switch ( CRYPT_AES_MODE ) {
+            case CRYPT_AES_MODE_MCRYPT:
+                switch ($mode) {
+                    case CRYPT_AES_MODE_ECB:
+                        $this->paddable = true;
+                        $this->mode = MCRYPT_MODE_ECB;
+                        break;
+                    case CRYPT_AES_MODE_CTR:
+                        // ctr doesn't have a constant associated with it even though it appears to be fairly widely
+                        // supported.  in lieu of knowing just how widely supported it is, i've, for now, opted not to
+                        // include a compatibility layer.  the layer has been implemented but, for now, is commented out.
+                        $this->mode = 'ctr';
+                        //$this->mode = in_array('ctr', mcrypt_list_modes()) ? 'ctr' : CRYPT_AES_MODE_CTR;
+                        break;
+                    case CRYPT_AES_MODE_CFB:
+                        $this->mode = 'ncfb';
+                        break;
+                    case CRYPT_AES_MODE_OFB:
+                        $this->mode = MCRYPT_MODE_NOFB;
+                        break;
+                    case CRYPT_AES_MODE_CBC:
+                    default:
+                        $this->paddable = true;
+                        $this->mode = MCRYPT_MODE_CBC;
+                }
+
+                break;
+            default:
+                switch ($mode) {
+                    case CRYPT_AES_MODE_ECB:
+                        $this->paddable = true;
+                        $this->mode = CRYPT_RIJNDAEL_MODE_ECB;
+                        break;
+                    case CRYPT_AES_MODE_CTR:
+                        $this->mode = CRYPT_RIJNDAEL_MODE_CTR;
+                        break;
+                    case CRYPT_AES_MODE_CFB:
+                        $this->mode = CRYPT_RIJNDAEL_MODE_CFB;
+                        break;
+                    case CRYPT_AES_MODE_OFB:
+                        $this->mode = CRYPT_RIJNDAEL_MODE_OFB;
+                        break;
+                    case CRYPT_AES_MODE_CBC:
+                    default:
+                        $this->paddable = true;
+                        $this->mode = CRYPT_RIJNDAEL_MODE_CBC;
+                }
+        }
+
+        if (CRYPT_AES_MODE == CRYPT_AES_MODE_INTERNAL) {
+            parent::Crypt_Rijndael($this->mode);
+        }
+
+    }
+
+    /**
+     * Dummy function
+     *
+     * Since Crypt_AES extends Crypt_Rijndael, this function is, technically, available, but it doesn't do anything.
+     *
+     * @access public
+     * @param Integer $length
+     */
+    function setBlockLength($length)
+    {
+        return;
+    }
+
+    /**
+     * Sets the initialization vector. (optional)
+     *
+     * SetIV is not required when CRYPT_RIJNDAEL_MODE_ECB is being used.  If not explictly set, it'll be assumed
+     * to be all zero's.
+     *
+     * @access public
+     * @param String $iv
+     */
+    function setIV($iv)
+    {
+        parent::setIV($iv);
+        if ( CRYPT_AES_MODE == CRYPT_AES_MODE_MCRYPT ) {
+            $this->changed = true;
+        }
+    }
+
+    /**
+     * Encrypts a message.
+     *
+     * $plaintext will be padded with up to 16 additional bytes.  Other AES implementations may or may not pad in the
+     * same manner.  Other common approaches to padding and the reasons why it's necessary are discussed in the following
+     * URL:
+     *
+     * {@link http://www.di-mgt.com.au/cryptopad.html http://www.di-mgt.com.au/cryptopad.html}
+     *
+     * An alternative to padding is to, separately, send the length of the file.  This is what SSH, in fact, does.
+     * strlen($plaintext) will still need to be a multiple of 16, however, arbitrary values can be added to make it that
+     * length.
+     *
+     * @see Crypt_AES::decrypt()
+     * @access public
+     * @param String $plaintext
+     */
+    function encrypt($plaintext)
+    {
+        if ( CRYPT_AES_MODE == CRYPT_AES_MODE_MCRYPT ) {
+            $this->_mcryptSetup();
+
+            // re: http://phpseclib.sourceforge.net/cfb-demo.phps
+            // using mcrypt's default handing of CFB the above would output two different things.  using phpseclib's
+            // rewritten CFB implementation the above outputs the same thing twice.
+            if ($this->mode == 'ncfb' && $this->continuousBuffer) {
+                $iv = &$this->encryptIV;
+                $pos = &$this->enbuffer['pos'];
+                $len = strlen($plaintext);
+                $ciphertext = '';
+                $i = 0;
+                if ($pos) {
+                    $orig_pos = $pos;
+                    $max = 16 - $pos;
+                    if ($len >= $max) {
+                        $i = $max;
+                        $len-= $max;
+                        $pos = 0;
+                    } else {
+                        $i = $len;
+                        $pos+= $len;
+                        $len = 0;
+                    }
+                    $ciphertext = substr($iv, $orig_pos) ^ $plaintext;
+                    $iv = substr_replace($iv, $ciphertext, $orig_pos, $i);
+                    $this->enbuffer['enmcrypt_init'] = true;
+                }
+                if ($len >= 16) {
+                    if ($this->enbuffer['enmcrypt_init'] === false || $len > 280) {
+                        if ($this->enbuffer['enmcrypt_init'] === true) {
+                            mcrypt_generic_init($this->enmcrypt, $this->key, $iv);
+                            $this->enbuffer['enmcrypt_init'] = false;
+                        }
+                        $ciphertext.= mcrypt_generic($this->enmcrypt, substr($plaintext, $i, $len - $len % 16));
+                        $iv = substr($ciphertext, -16);
+                        $len%= 16;
+                    } else {
+                        while ($len >= 16) {
+                            $iv = mcrypt_generic($this->ecb, $iv) ^ substr($plaintext, $i, 16);
+                            $ciphertext.= $iv;
+                            $len-= 16;
+                            $i+= 16;
+                        }
+                    }
+                }
+
+                if ($len) {
+                    $iv = mcrypt_generic($this->ecb, $iv);
+                    $block = $iv ^ substr($plaintext, -$len);
+                    $iv = substr_replace($iv, $block, 0, $len);
+                    $ciphertext.= $block;
+                    $pos = $len;
+                }
+
+                return $ciphertext;
+            }
+
+            if ($this->paddable) {
+                $plaintext = $this->_pad($plaintext);
+            }
+
+            $ciphertext = mcrypt_generic($this->enmcrypt, $plaintext);
+
+            if (!$this->continuousBuffer) {
+                mcrypt_generic_init($this->enmcrypt, $this->key, $this->iv);
+            }
+
+            return $ciphertext;
+        }
+
+        return parent::encrypt($plaintext);
+    }
+
+    /**
+     * Decrypts a message.
+     *
+     * If strlen($ciphertext) is not a multiple of 16, null bytes will be added to the end of the string until it is.
+     *
+     * @see Crypt_AES::encrypt()
+     * @access public
+     * @param String $ciphertext
+     */
+    function decrypt($ciphertext)
+    {
+        if ( CRYPT_AES_MODE == CRYPT_AES_MODE_MCRYPT ) {
+            $this->_mcryptSetup();
+
+            if ($this->mode == 'ncfb' && $this->continuousBuffer) {
+                $iv = &$this->decryptIV;
+                $pos = &$this->debuffer['pos'];
+                $len = strlen($ciphertext);
+                $plaintext = '';
+                $i = 0;
+                if ($pos) {
+                    $orig_pos = $pos;
+                    $max = 16 - $pos;
+                    if ($len >= $max) {
+                        $i = $max;
+                        $len-= $max;
+                        $pos = 0;
+                    } else {
+                        $i = $len;
+                        $pos+= $len;
+                        $len = 0;
+                    }
+                    // ie. $i = min($max, $len), $len-= $i, $pos+= $i, $pos%= $blocksize
+                    $plaintext = substr($iv, $orig_pos) ^ $ciphertext;
+                    $iv = substr_replace($iv, substr($ciphertext, 0, $i), $orig_pos, $i);
+                }
+                if ($len >= 16) {
+                    $cb = substr($ciphertext, $i, $len - $len % 16);
+                    $plaintext.= mcrypt_generic($this->ecb, $iv . $cb) ^ $cb;
+                    $iv = substr($cb, -16);
+                    $len%= 16;
+                }
+                if ($len) {
+                    $iv = mcrypt_generic($this->ecb, $iv);
+                    $plaintext.= $iv ^ substr($ciphertext, -$len);
+                    $iv = substr_replace($iv, substr($ciphertext, -$len), 0, $len);
+                    $pos = $len;
+                }
+
+                return $plaintext;
+            }
+
+            if ($this->paddable) {
+                // we pad with chr(0) since that's what mcrypt_generic does.  to quote from http://php.net/function.mcrypt-generic :
+                // "The data is padded with "\0" to make sure the length of the data is n * blocksize."
+                $ciphertext = str_pad($ciphertext, (strlen($ciphertext) + 15) & 0xFFFFFFF0, chr(0));
+            }
+
+            $plaintext = mdecrypt_generic($this->demcrypt, $ciphertext);
+
+            if (!$this->continuousBuffer) {
+                mcrypt_generic_init($this->demcrypt, $this->key, $this->iv);
+            }
+
+            return $this->paddable ? $this->_unpad($plaintext) : $plaintext;
+        }
+
+        return parent::decrypt($ciphertext);
+    }
+
+    /**
+     * Setup mcrypt
+     *
+     * Validates all the variables.
+     *
+     * @access private
+     */
+    function _mcryptSetup()
+    {
+        if (!$this->changed) {
+            return;
+        }
+
+        if (!$this->explicit_key_length) {
+            // this just copied from Crypt_Rijndael::_setup()
+            $length = strlen($this->key) >> 2;
+            if ($length > 8) {
+                $length = 8;
+            } else if ($length < 4) {
+                $length = 4;
+            }
+            $this->Nk = $length;
+            $this->key_size = $length << 2;
+        }
+
+        switch ($this->Nk) {
+            case 4: // 128
+                $this->key_size = 16;
+                break;
+            case 5: // 160
+            case 6: // 192
+                $this->key_size = 24;
+                break;
+            case 7: // 224
+            case 8: // 256
+                $this->key_size = 32;
+        }
+
+        $this->key = str_pad(substr($this->key, 0, $this->key_size), $this->key_size, chr(0));
+        $this->encryptIV = $this->decryptIV = $this->iv = str_pad(substr($this->iv, 0, 16), 16, chr(0));
+
+        if (!isset($this->enmcrypt)) {
+            $mode = $this->mode;
+            //$mode = $this->mode == CRYPT_AES_MODE_CTR ? MCRYPT_MODE_ECB : $this->mode;
+
+            $this->demcrypt = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', $mode, '');
+            $this->enmcrypt = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', $mode, '');
+
+            if ($mode == 'ncfb') {
+                $this->ecb = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', MCRYPT_MODE_ECB, '');
+            }
+
+        } // else should mcrypt_generic_deinit be called?
+
+        mcrypt_generic_init($this->demcrypt, $this->key, $this->iv);
+        mcrypt_generic_init($this->enmcrypt, $this->key, $this->iv);
+
+        if ($this->mode == 'ncfb') {
+            mcrypt_generic_init($this->ecb, $this->key, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
+        }
+
+        $this->changed = false;
+    }
+
+    /**
+     * Treat consecutive "packets" as if they are a continuous buffer.
+     *
+     * The default behavior.
+     *
+     * @see Crypt_Rijndael::disableContinuousBuffer()
+     * @access public
+     */
+    function enableContinuousBuffer()
+    {
+        parent::enableContinuousBuffer();
+
+        if (CRYPT_AES_MODE == CRYPT_AES_MODE_MCRYPT) {
+            $this->enbuffer['enmcrypt_init'] = true;
+            $this->debuffer['demcrypt_init'] = true;
+        }
+    }
+
+    /**
+     * Treat consecutive packets as if they are a discontinuous buffer.
+     *
+     * The default behavior.
+     *
+     * @see Crypt_Rijndael::enableContinuousBuffer()
+     * @access public
+     */
+    function disableContinuousBuffer()
+    {
+        parent::disableContinuousBuffer();
+
+        if (CRYPT_AES_MODE == CRYPT_AES_MODE_MCRYPT) {
+            mcrypt_generic_init($this->enmcrypt, $this->key, $this->iv);
+            mcrypt_generic_init($this->demcrypt, $this->key, $this->iv);
+        }
+    }
+}
+
+// vim: ts=4:sw=4:et:
+// vim6: fdl=1:

include/pear/Crypt/Random.php

+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Random Number Generator
+ *
+ * PHP versions 4 and 5
+ *
+ * Here's a short example of how to use this library:
+ * <code>
+ * <?php
+ *    include('Crypt/Random.php');
+ *
+ *    echo bin2hex(crypt_random_string(8));
+ * ?>
+ * </code>
+ *
+ * LICENSE: Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @category   Crypt
+ * @package    Crypt_Random
+ * @author     Jim Wigginton <terrafrost@php.net>
+ * @copyright  MMVII Jim Wigginton
+ * @license    http://www.opensource.org/licenses/mit-license.html  MIT License
+ * @link       http://phpseclib.sourceforge.net
+ */
+
+/**
+ * "Is Windows" test
+ *
+ * @access private
+ */
+define('CRYPT_RANDOM_IS_WINDOWS', strtoupper(substr(PHP_OS, 0, 3)) === 'WIN');
+
+/**
+ * Generate a random string.
+ *
+ * Although microoptimizations are generally discouraged as they impair readability this function is ripe with
+ * microoptimizations because this function has the potential of being called a huge number of times.
+ * eg. for RSA key generation.
+ *
+ * @param Integer $length
+ * @return String
+ * @access public
+ */
+function crypt_random_string($length)
+{
+    if (CRYPT_RANDOM_IS_WINDOWS) {
+        // method 1. prior to PHP 5.3 this would call rand() on windows hence the function_exists('class_alias') call.
+        // ie. class_alias is a function that was introduced in PHP 5.3
+        if (function_exists('mcrypt_create_iv') && function_exists('class_alias')) {
+            return mcrypt_create_iv($length);
+        }
+        // method 2. openssl_random_pseudo_bytes was introduced in PHP 5.3.0 but prior to PHP 5.3.4 there was,
+        // to quote <http://php.net/ChangeLog-5.php#5.3.4>, "possible blocking behavior". as of 5.3.4
+        // openssl_random_pseudo_bytes and mcrypt_create_iv do the exact same thing on Windows. ie. they both
+        // call php_win32_get_random_bytes():
+        //
+        // https://github.com/php/php-src/blob/7014a0eb6d1611151a286c0ff4f2238f92c120d6/ext/openssl/openssl.c#L5008
+        // https://github.com/php/php-src/blob/7014a0eb6d1611151a286c0ff4f2238f92c120d6/ext/mcrypt/mcrypt.c#L1392
+        //
+        // php_win32_get_random_bytes() is defined thusly:
+        //
+        // https://github.com/php/php-src/blob/7014a0eb6d1611151a286c0ff4f2238f92c120d6/win32/winutil.c#L80
+        //
+        // we're calling it, all the same, in the off chance that the mcrypt extension is not available
+        if (function_exists('openssl_random_pseudo_bytes') && version_compare(PHP_VERSION, '5.3.4', '>=')) {
+            return openssl_random_pseudo_bytes($length);
+        }
+    } else {
+        // method 1. the fastest
+        if (function_exists('openssl_random_pseudo_bytes')) {
+            return openssl_random_pseudo_bytes($length);
+        }
+        // method 2
+        static $fp = true;
+        if ($fp === true) {
+            // warning's will be output unles the error suppression operator is used. errors such as
+            // "open_basedir restriction in effect", "Permission denied", "No such file or directory", etc.
+            $fp = @fopen('/dev/urandom', 'rb');
+        }
+        if ($fp !== true && $fp !== false) { // surprisingly faster than !is_bool() or is_resource()
+            return fread($fp, $length);
+        }
+        // method 3. pretty much does the same thing as method 2 per the following url:
+        // https://github.com/php/php-src/blob/7014a0eb6d1611151a286c0ff4f2238f92c120d6/ext/mcrypt/mcrypt.c#L1391
+        // surprisingly slower than method 2. maybe that's because mcrypt_create_iv does a bunch of error checking that we're
+        // not doing. regardless, this'll only be called if this PHP script couldn't open /dev/urandom due to open_basedir
+        // restrictions or some such
+        if (function_exists('mcrypt_create_iv')) {
+            return mcrypt_create_iv($length, MCRYPT_DEV_URANDOM);
+        }
+    }
+    // at this point we have no choice but to use a pure-PHP CSPRNG
+
+    // cascade entropy across multiple PHP instances by fixing the session and collecting all
+    // environmental variables, including the previous session data and the current session
+    // data.
+    //
+    // mt_rand seeds itself by looking at the PID and the time, both of which are (relatively)
+    // easy to guess at. linux uses mouse clicks, keyboard timings, etc, as entropy sources, but
+    // PHP isn't low level to be able to use those as sources and on a web server there's not likely
+    // going to be a ton of keyboard or mouse action. web servers do have one thing that we can use
+    // however. a ton of people visiting the website. obviously you don't want to base your seeding
+    // soley on parameters a potential attacker sends but (1) not everything in $_SERVER is controlled
+    // by the user and (2) this isn't just looking at the data sent by the current user - it's based
+    // on the data sent by all users. one user requests the page and a hash of their info is saved.
+    // another user visits the page and the serialization of their data is utilized along with the
+    // server envirnment stuff and a hash of the previous http request data (which itself utilizes
+    // a hash of the session data before that). certainly an attacker should be assumed to have
+    // full control over his own http requests. he, however, is not going to have control over
+    // everyone's http requests.
+    static $crypto = false, $v;
+    if ($crypto === false) {
+        // save old session data
+        $old_session_id = session_id();
+        $old_use_cookies = ini_get('session.use_cookies');
+        $old_session_cache_limiter = session_cache_limiter();
+        if (isset($_SESSION)) {
+            $_OLD_SESSION = $_SESSION;
+        }
+        if ($old_session_id != '') {
+            session_write_close();
+        }
+
+        session_id(1);
+        ini_set('session.use_cookies', 0);
+        session_cache_limiter('');
+        session_start();
+
+        $v = $seed = $_SESSION['seed'] = pack('H*', sha1(
+            serialize($_SERVER) .
+            serialize($_POST) .
+            serialize($_GET) .
+            serialize($_COOKIE) .
+            serialize($GLOBALS) .
+            serialize($_SESSION) .
+            serialize($_OLD_SESSION)
+        ));
+        if (!isset($_SESSION['count'])) {
+            $_SESSION['count'] = 0;
+        }
+        $_SESSION['count']++;
+
+        session_write_close();
+
+        // restore old session data
+        if ($old_session_id != '') {
+            session_id($old_session_id);
+            session_start();
+            ini_set('session.use_cookies', $old_use_cookies);
+            session_cache_limiter($old_session_cache_limiter);
+        } else {
+           if (isset($_OLD_SESSION)) {
+               $_SESSION = $_OLD_SESSION;
+               unset($_OLD_SESSION);
+            } else {
+                unset($_SESSION);
+            }
+        }
+
+        // in SSH2 a shared secret and an exchange hash are generated through the key exchange process.
+        // the IV client to server is the hash of that "nonce" with the letter A and for the encryption key it's the letter C.
+        // if the hash doesn't produce enough a key or an IV that's long enough concat successive hashes of the
+        // original hash and the current hash. we'll be emulating that. for more info see the following URL:
+        //
+        // http://tools.ietf.org/html/rfc4253#section-7.2
+        //
+        // see the is_string($crypto) part for an example of how to expand the keys
+        $key = pack('H*', sha1($seed . 'A'));
+        $iv = pack('H*', sha1($seed . 'C'));
+
+        // ciphers are used as per the nist.gov link below. also, see this link:
+        //
+        // http://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator#Designs_based_on_cryptographic_primitives
+        switch (true) {
+            case class_exists('Crypt_AES'):
+                $crypto = new Crypt_AES(CRYPT_AES_MODE_CTR);
+                break;
+            case class_exists('Crypt_TripleDES'):
+                $crypto = new Crypt_TripleDES(CRYPT_DES_MODE_CTR);
+                break;
+            case class_exists('Crypt_DES'):
+                $crypto = new Crypt_DES(CRYPT_DES_MODE_CTR);
+                break;
+            case class_exists('Crypt_RC4'):
+                $crypto = new Crypt_RC4();
+                break;
+            default:
+                $crypto = $seed;
+                return crypt_random_string($length);
+        }
+
+        $crypto->setKey($key);
+        $crypto->setIV($iv);
+        $crypto->enableContinuousBuffer();
+    }
+
+    if (is_string($crypto)) {
+        // the following is based off of ANSI X9.31:
+        //
+        // http://csrc.nist.gov/groups/STM/cavp/documents/rng/931rngext.pdf
+        //
+        // OpenSSL uses that same standard for it's random numbers:
+        //
+        // http://www.opensource.apple.com/source/OpenSSL/OpenSSL-38/openssl/fips-1.0/rand/fips_rand.c
+        // (do a search for "ANS X9.31 A.2.4")
+        //
+        // ANSI X9.31 recommends ciphers be used and phpseclib does use them if they're available (see
+        // later on in the code) but if they're not we'll use sha1
+        $result = '';
+        while (strlen($result) < $length) { // each loop adds 20 bytes
+            // microtime() isn't packed as "densely" as it could be but then neither is that the idea.
+            // the idea is simply to ensure that each "block" has a unique element to it.
+            $i = pack('H*', sha1(microtime()));
+            $r = pack('H*', sha1($i ^ $v));
+            $v = pack('H*', sha1($r ^ $i));
+            $result.= $r;
+        }
+        return substr($result, 0, $length);
+    }
+
+    //return $crypto->encrypt(str_repeat("\0", $length));
+
+    $result = '';
+    while (strlen($result) < $length) {
+        $i = $crypto->encrypt(microtime());
+        $r = $crypto->encrypt($i ^ $v);
+        $v = $crypto->encrypt($r ^ $i);
+        $result.= $r;
+    }
+    return substr($result, 0, $length);
+}