Adding upstream version 2.11.4.upstream/2.11.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

17 files changed, 2132 insertions, 0 deletions

diff --git a/library/vendor/Zend/Crypt/DiffieHellman.php b/library/vendor/Zend/Crypt/DiffieHellman.php
new file mode 100644
index 0000000..851f871
--- /dev/null
+++ b/library/vendor/Zend/Crypt/DiffieHellman.php
@@ -0,0 +1,378 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage DiffieHellman
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * PHP implementation of the Diffie-Hellman public key encryption algorithm.
+ * Allows two unassociated parties to establish a joint shared secret key
+ * to be used in encrypting subsequent communications.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_DiffieHellman
+{
+
+    /**
+     * Static flag to select whether to use PHP5.3's openssl extension
+     * if available.
+     *
+     * @var boolean
+     */
+    public static $useOpenssl = true;
+
+    /**
+     * Default large prime number; required by the algorithm.
+     *
+     * @var string
+     */
+    private $_prime = null;
+
+    /**
+     * The default generator number. This number must be greater than 0 but
+     * less than the prime number set.
+     *
+     * @var string
+     */
+    private $_generator = null;
+
+    /**
+     * A private number set by the local user. It's optional and will
+     * be generated if not set.
+     *
+     * @var string
+     */
+    private $_privateKey = null;
+
+    /**
+     * BigInteger support object courtesy of Zend_Crypt_Math
+     *
+     * @var Zend_Crypt_Math_BigInteger
+     */
+    private $_math = null;
+
+    /**
+     * The public key generated by this instance after calling generateKeys().
+     *
+     * @var string
+     */
+    private $_publicKey = null;
+
+    /**
+     * The shared secret key resulting from a completed Diffie Hellman
+     * exchange
+     *
+     * @var string
+     */
+    private $_secretKey = null;
+
+    /**
+     * Constants
+     */
+    const BINARY = 'binary';
+    const NUMBER = 'number';
+    const BTWOC  = 'btwoc';
+
+    /**
+     * Constructor; if set construct the object using the parameter array to
+     * set values for Prime, Generator and Private.
+     * If a Private Key is not set, one will be generated at random.
+     *
+     * @param string $prime
+     * @param string $generator
+     * @param string $privateKey
+     * @param string $privateKeyType
+     */
+    public function __construct($prime, $generator, $privateKey = null, $privateKeyType = self::NUMBER)
+    {
+        $this->setPrime($prime);
+        $this->setGenerator($generator);
+        if ($privateKey !== null) {
+            $this->setPrivateKey($privateKey, $privateKeyType);
+        }
+        $this->setBigIntegerMath();
+    }
+
+    /**
+     * Generate own public key. If a private number has not already been
+     * set, one will be generated at this stage.
+     *
+     * @return Zend_Crypt_DiffieHellman
+     */
+    public function generateKeys()
+    {
+        if (function_exists('openssl_dh_compute_key') && self::$useOpenssl !== false) {
+            $details = array();
+            $details['p'] = $this->getPrime();
+            $details['g'] = $this->getGenerator();
+            if ($this->hasPrivateKey()) {
+                $details['priv_key'] = $this->getPrivateKey();
+            }
+            $opensslKeyResource = openssl_pkey_new( array('dh' => $details) );
+            $data = openssl_pkey_get_details($opensslKeyResource);
+            $this->setPrivateKey($data['dh']['priv_key'], self::BINARY);
+            $this->setPublicKey($data['dh']['pub_key'], self::BINARY);
+        } else {
+            // Private key is lazy generated in the absence of PHP 5.3's ext/openssl
+            $publicKey = $this->_math->powmod($this->getGenerator(), $this->getPrivateKey(), $this->getPrime());
+            $this->setPublicKey($publicKey);
+        }
+        return $this;
+    }
+
+    /**
+     * Setter for the value of the public number
+     *
+     * @param string $number
+     * @param string $type
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return Zend_Crypt_DiffieHellman
+     */
+    public function setPublicKey($number, $type = self::NUMBER)
+    {
+        if ($type == self::BINARY) {
+            $number = $this->_math->fromBinary($number);
+        }
+        if (!preg_match("/^\d+$/", $number)) {
+            throw new Zend_Crypt_DiffieHellman_Exception('invalid parameter; not a positive natural number');
+        }
+        $this->_publicKey = (string) $number;
+        return $this;
+    }
+
+    /**
+     * Returns own public key for communication to the second party to this
+     * transaction.
+     *
+     * @param string $type
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return string
+     */
+    public function getPublicKey($type = self::NUMBER)
+    {
+        if ($this->_publicKey === null) {
+            throw new Zend_Crypt_DiffieHellman_Exception('A public key has not yet been generated using a prior call to generateKeys()');
+        }
+        if ($type == self::BINARY) {
+            return $this->_math->toBinary($this->_publicKey);
+        } elseif ($type == self::BTWOC) {
+            return $this->_math->btwoc($this->_math->toBinary($this->_publicKey));
+        }
+        return $this->_publicKey;
+    }
+
+    /**
+     * Compute the shared secret key based on the public key received from the
+     * the second party to this transaction. This should agree to the secret
+     * key the second party computes on our own public key.
+     * Once in agreement, the key is known to only to both parties.
+     * By default, the function expects the public key to be in binary form
+     * which is the typical format when being transmitted.
+     *
+     * If you need the binary form of the shared secret key, call
+     * getSharedSecretKey() with the optional parameter for Binary output.
+     *
+     * @param string $publicKey
+     * @param string $type
+     * @param string $output
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return mixed
+     */
+    public function computeSecretKey($publicKey, $type = self::NUMBER, $output = self::NUMBER)
+    {
+        if ($type == self::BINARY) {
+            $publicKey = $this->_math->fromBinary($publicKey);
+        }
+        if (!preg_match("/^\d+$/", $publicKey)) {
+            throw new Zend_Crypt_DiffieHellman_Exception('invalid parameter; not a positive natural number');
+        }
+        if (function_exists('openssl_dh_compute_key') && self::$useOpenssl !== false) {
+            $this->_secretKey = openssl_dh_compute_key($publicKey, $this->getPublicKey());
+        } else {
+            $this->_secretKey = $this->_math->powmod($publicKey, $this->getPrivateKey(), $this->getPrime());
+        }
+        return $this->getSharedSecretKey($output);
+    }
+
+    /**
+     * Return the computed shared secret key from the DiffieHellman transaction
+     *
+     * @param string $type
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return string
+     */
+    public function getSharedSecretKey($type = self::NUMBER)
+    {
+        if (!isset($this->_secretKey)) {
+            throw new Zend_Crypt_DiffieHellman_Exception('A secret key has not yet been computed; call computeSecretKey()');
+        }
+        if ($type == self::BINARY) {
+            return $this->_math->toBinary($this->_secretKey);
+        } elseif ($type == self::BTWOC) {
+            return $this->_math->btwoc($this->_math->toBinary($this->_secretKey));
+        }
+        return $this->_secretKey;
+    }
+
+    /**
+     * Setter for the value of the prime number
+     *
+     * @param string $number
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return Zend_Crypt_DiffieHellman
+     */
+    public function setPrime($number)
+    {
+        if (!preg_match("/^\d+$/", $number) || $number < 11) {
+            throw new Zend_Crypt_DiffieHellman_Exception('invalid parameter; not a positive natural number or too small: should be a large natural number prime');
+        }
+        $this->_prime = (string) $number;
+        return $this;
+    }
+
+    /**
+     * Getter for the value of the prime number
+     *
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return string
+     */
+    public function getPrime()
+    {
+        if (!isset($this->_prime)) {
+            throw new Zend_Crypt_DiffieHellman_Exception('No prime number has been set');
+        }
+        return $this->_prime;
+    }
+
+    /**
+     * Setter for the value of the generator number
+     *
+     * @param string $number
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return Zend_Crypt_DiffieHellman
+     */
+    public function setGenerator($number)
+    {
+        if (!preg_match("/^\d+$/", $number) || $number < 2) {
+            throw new Zend_Crypt_DiffieHellman_Exception('invalid parameter; not a positive natural number greater than 1');
+        }
+        $this->_generator = (string) $number;
+        return $this;
+    }
+
+    /**
+     * Getter for the value of the generator number
+     *
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return string
+     */
+    public function getGenerator()
+    {
+        if (!isset($this->_generator)) {
+            throw new Zend_Crypt_DiffieHellman_Exception('No generator number has been set');
+        }
+        return $this->_generator;
+    }
+
+    /**
+     * Setter for the value of the private number
+     *
+     * @param string $number
+     * @param string $type
+     * @throws Zend_Crypt_DiffieHellman_Exception
+     * @return Zend_Crypt_DiffieHellman
+     */
+    public function setPrivateKey($number, $type = self::NUMBER)
+    {
+        if ($type == self::BINARY) {
+            $number = $this->_math->fromBinary($number);
+        }
+        if (!preg_match("/^\d+$/", $number)) {
+            throw new Zend_Crypt_DiffieHellman_Exception('invalid parameter; not a positive natural number');
+        }
+        $this->_privateKey = (string) $number;
+        return $this;
+    }
+
+    /**
+     * Getter for the value of the private number
+     *
+     * @param string $type
+     * @return string
+     */
+    public function getPrivateKey($type = self::NUMBER)
+    {
+        if (!$this->hasPrivateKey()) {
+            $this->setPrivateKey($this->_generatePrivateKey(), self::BINARY);
+        }
+        if ($type == self::BINARY) {
+            return $this->_math->toBinary($this->_privateKey);
+        } elseif ($type == self::BTWOC) {
+            return $this->_math->btwoc($this->_math->toBinary($this->_privateKey));
+        }
+        return $this->_privateKey;
+    }
+
+    /**
+     * Check whether a private key currently exists.
+     *
+     * @return boolean
+     */
+    public function hasPrivateKey()
+    {
+        return isset($this->_privateKey);
+    }
+
+    /**
+     * Setter to pass an extension parameter which is used to create
+     * a specific BigInteger instance for a specific extension type.
+     * Allows manual setting of the class in case of an extension
+     * problem or bug.
+     *
+     * @param string $extension
+     * @return void
+     */
+    public function setBigIntegerMath($extension = null)
+    {
+        /**
+         * @see Zend_Crypt_Math
+         */
+        $this->_math = new Zend_Crypt_Math($extension);
+    }
+
+    /**
+     * In the event a private number/key has not been set by the user,
+     * or generated by ext/openssl, a best attempt will be made to
+     * generate a random key. Having a random number generator installed
+     * on linux/bsd is highly recommended! The alternative is not recommended
+     * for production unless without any other option.
+     *
+     * @return string
+     */
+    protected function _generatePrivateKey()
+    {
+        $rand = $this->_math->rand($this->getGenerator(), $this->getPrime());
+        return $rand;
+    }
+
+}
diff --git a/library/vendor/Zend/Crypt/DiffieHellman/Exception.php b/library/vendor/Zend/Crypt/DiffieHellman/Exception.php
new file mode 100644
index 0000000..7a84526
--- /dev/null
+++ b/library/vendor/Zend/Crypt/DiffieHellman/Exception.php
@@ -0,0 +1,35 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage DiffieHellman
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Exception
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_DiffieHellman_Exception extends Zend_Crypt_Exception
+{
+}
diff --git a/library/vendor/Zend/Crypt/Exception.php b/library/vendor/Zend/Crypt/Exception.php
new file mode 100644
index 0000000..826f9f1
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Exception.php
@@ -0,0 +1,34 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Exception
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Exception extends Zend_Exception
+{
+}
diff --git a/library/vendor/Zend/Crypt/Hmac.php b/library/vendor/Zend/Crypt/Hmac.php
new file mode 100644
index 0000000..bd8814d
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Hmac.php
@@ -0,0 +1,178 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Hmac
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt
+ */
+
+/**
+ * PHP implementation of the RFC 2104 Hash based Message Authentication Code
+ * algorithm.
+ *
+ * @todo  Patch for refactoring failed tests (key block sizes >80 using internal algo)
+ * @todo       Check if mhash() is a required alternative (will be PECL-only soon)
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Hmac extends Zend_Crypt
+{
+
+    /**
+     * The key to use for the hash
+     *
+     * @var string
+     */
+    protected static $_key = null;
+
+    /**
+     * pack() format to be used for current hashing method
+     *
+     * @var string
+     */
+    protected static $_packFormat = null;
+
+    /**
+     * Hashing algorithm; can be the md5/sha1 functions or any algorithm name
+     * listed in the output of PHP 5.1.2+ hash_algos().
+     *
+     * @var string
+     */
+    protected static $_hashAlgorithm = 'md5';
+
+    /**
+     * List of algorithms supported my mhash()
+     *
+     * @var array
+     */
+    protected static $_supportedMhashAlgorithms = array('adler32',' crc32', 'crc32b', 'gost',
+            'haval128', 'haval160', 'haval192', 'haval256', 'md4', 'md5', 'ripemd160',
+            'sha1', 'sha256', 'tiger', 'tiger128', 'tiger160');
+
+    /**
+     * Constants representing the output mode of the hash algorithm
+     */
+    const STRING = 'string';
+    const BINARY = 'binary';
+
+    /**
+     * Performs a HMAC computation given relevant details such as Key, Hashing
+     * algorithm, the data to compute MAC of, and an output format of String,
+     * Binary notation or BTWOC.
+     *
+     * @param string $key
+     * @param string $hash
+     * @param string $data
+     * @param string $output
+     * @throws Zend_Crypt_Hmac_Exception
+     * @return string
+     */
+    public static function compute($key, $hash, $data, $output = self::STRING)
+    {
+        // set the key
+        if (!isset($key) || empty($key)) {
+            throw new Zend_Crypt_Hmac_Exception('provided key is null or empty');
+        }
+        self::$_key = $key;
+
+        // set the hash
+        self::_setHashAlgorithm($hash);
+
+        // perform hashing and return
+        return self::_hash($data, $output);
+    }
+
+    /**
+     * Setter for the hash method.
+     *
+     * @param string $hash
+     * @throws Zend_Crypt_Hmac_Exception
+     * @return Zend_Crypt_Hmac
+     */
+    protected static function _setHashAlgorithm($hash)
+    {
+        if (!isset($hash) || empty($hash)) {
+            throw new Zend_Crypt_Hmac_Exception('provided hash string is null or empty');
+        }
+
+        $hash = strtolower($hash);
+        $hashSupported = false;
+
+        if (function_exists('hash_algos') && in_array($hash, hash_algos())) {
+            $hashSupported = true;
+        }
+
+        if ($hashSupported === false && function_exists('mhash') && in_array($hash, self::$_supportedAlgosMhash)) {
+            $hashSupported = true;
+        }
+
+        if ($hashSupported === false) {
+            throw new Zend_Crypt_Hmac_Exception('hash algorithm provided is not supported on this PHP installation; please enable the hash or mhash extensions');
+        }
+        self::$_hashAlgorithm = $hash;
+    }
+
+    /**
+     * Perform HMAC and return the keyed data
+     *
+     * @param string $data
+     * @param string $output
+     * @param bool $internal Option to not use hash() functions for testing
+     * @return string
+     */
+    protected static function _hash($data, $output = self::STRING, $internal = false)
+    {
+        if (function_exists('hash_hmac')) {
+            if ($output == self::BINARY) {
+                return hash_hmac(self::$_hashAlgorithm, $data, self::$_key, true);
+            }
+            return hash_hmac(self::$_hashAlgorithm, $data, self::$_key);
+        }
+
+        if (function_exists('mhash')) {
+            if ($output == self::BINARY) {
+                return mhash(self::_getMhashDefinition(self::$_hashAlgorithm), $data, self::$_key);
+            }
+            $bin = mhash(self::_getMhashDefinition(self::$_hashAlgorithm), $data, self::$_key);
+            return bin2hex($bin);
+        }
+    }
+
+    /**
+     * Since MHASH accepts an integer constant representing the hash algorithm
+     * we need to make a small detour to get the correct integer matching our
+     * algorithm's name.
+     *
+     * @param string $hashAlgorithm
+     * @return integer
+     */
+    protected static function _getMhashDefinition($hashAlgorithm)
+    {
+        for ($i = 0; $i <= mhash_count(); $i++)
+        {
+            $types[mhash_get_hash_name($i)] = $i;
+        }
+        return $types[strtoupper($hashAlgorithm)];
+    }
+
+}
diff --git a/library/vendor/Zend/Crypt/Hmac/Exception.php b/library/vendor/Zend/Crypt/Hmac/Exception.php
new file mode 100644
index 0000000..9f266e0
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Hmac/Exception.php
@@ -0,0 +1,35 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Hmac
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Exception
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Hmac_Exception extends Zend_Crypt_Exception
+{
+}
diff --git a/library/vendor/Zend/Crypt/Math.php b/library/vendor/Zend/Crypt/Math.php
new file mode 100644
index 0000000..f39ac16
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Math.php
@@ -0,0 +1,186 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Math
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Math_BigInteger
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Math extends Zend_Crypt_Math_BigInteger
+{
+
+    /**
+     * Generate a pseudorandom number within the given range.
+     * Will attempt to read from a systems RNG if it exists or else utilises
+     * a simple random character to maximum length process. Simplicity
+     * is a factor better left for development...
+     *
+     * @param string|int $minimum
+     * @param string|int $maximum
+     * @return string
+     */
+    public function rand($minimum, $maximum)
+    {
+        if (file_exists('/dev/urandom')) {
+            $frandom = fopen('/dev/urandom', 'r');
+            if ($frandom !== false) {
+                return fread($frandom, strlen($maximum) - 1);
+            }
+        }
+        if (strlen($maximum) < 4) {
+            return mt_rand($minimum, $maximum - 1);
+        }
+        $rand = '';
+        $i2 = strlen($maximum) - 1;
+        for ($i = 1; $i < $i2; $i++) {
+            $rand .= mt_rand(0, 9);
+        }
+        $rand .= mt_rand(0, 9);
+        return $rand;
+    }
+
+    /**
+     * Return a random strings of $length bytes
+     *
+     * @param  integer $length
+     * @param  boolean $strong
+     * @return string
+     */
+    public static function randBytes($length, $strong = false)
+    {
+        $length = (int) $length;
+        if ($length <= 0) {
+            return false;
+        }
+        if (function_exists('random_bytes')) { // available in PHP 7
+            return random_bytes($length);
+        }
+        if (function_exists('mcrypt_create_iv')) {
+            $bytes = mcrypt_create_iv($length, MCRYPT_DEV_URANDOM);
+            if ($bytes !== false && strlen($bytes) === $length) {
+                return $bytes;
+            }
+        }
+        if (file_exists('/dev/urandom') && is_readable('/dev/urandom')) {
+            $frandom = fopen('/dev/urandom', 'r');
+            if ($frandom !== false) {
+                return fread($frandom, $length);
+            }
+        }
+        if (true === $strong) {
+            throw new Zend_Crypt_Exception(
+                'This PHP environment doesn\'t support secure random number generation. ' .
+                'Please consider installing the OpenSSL and/or Mcrypt extensions'
+            );
+        }
+        $rand = '';
+        for ($i = 0; $i < $length; $i++) {
+            $rand .= chr(mt_rand(0, 255));
+        }
+        return $rand;
+    }
+
+    /**
+     * Return a random integer between $min and $max
+     *
+     * @param  integer $min
+     * @param  integer $max
+     * @param  boolean $strong
+     * @return integer
+     */
+    public static function randInteger($min, $max, $strong = false)
+    {
+        if ($min > $max) {
+            throw new Zend_Crypt_Exception(
+                'The min parameter must be lower than max parameter'
+            );
+        }
+        $range = $max - $min;
+        if ($range == 0) {
+            return $max;
+        } elseif ($range > PHP_INT_MAX || is_float($range)) {
+            throw new Zend_Crypt_Exception(
+                'The supplied range is too great to generate'
+            );
+        }
+        if (function_exists('random_int')) { // available in PHP 7
+            return random_int($min, $max);
+        }
+        // calculate number of bits required to store range on this machine
+        $r = $range;
+        $bits = 0;
+        while ($r) {
+            $bits++;
+            $r >>= 1;
+        }
+        $bits   = (int) max($bits, 1);
+        $bytes  = (int) max(ceil($bits / 8), 1);
+        $filter = (int) ((1 << $bits) - 1);
+        do {
+            $rnd  = hexdec(bin2hex(self::randBytes($bytes, $strong)));
+            $rnd &= $filter;
+        } while ($rnd > $range);
+        return ($min + $rnd);
+    }
+
+    /**
+     * Get the big endian two's complement of a given big integer in
+     * binary notation
+     *
+     * @param string $long
+     * @return string
+     */
+    public function btwoc($long)
+    {
+        if (ord($long[0]) > 127) {
+            return "\x00" . $long;
+        }
+        return $long;
+    }
+
+    /**
+     * Translate a binary form into a big integer string
+     *
+     * @param string $binary
+     * @return string
+     */
+    public function fromBinary($binary)
+    {
+        return $this->_math->binaryToInteger($binary);
+    }
+
+    /**
+     * Translate a big integer string into a binary form
+     *
+     * @param string $integer
+     * @return string
+     */
+    public function toBinary($integer)
+    {
+        return $this->_math->integerToBinary($integer);
+    }
+}
diff --git a/library/vendor/Zend/Crypt/Math/BigInteger.php b/library/vendor/Zend/Crypt/Math/BigInteger.php
new file mode 100644
index 0000000..0b98cec
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Math/BigInteger.php
@@ -0,0 +1,113 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Math
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * Support for arbitrary precision mathematics in PHP.
+ *
+ * Zend_Crypt_Math_BigInteger is a wrapper across three PHP extensions: bcmath, gmp
+ * and big_int. Since each offer similar functionality, but availability of
+ * each differs across installations of PHP, this wrapper attempts to select
+ * the fastest option available and encapsulate a subset of its functionality
+ * which all extensions share in common.
+ *
+ * This class requires one of the three extensions to be available. BCMATH
+ * while the slowest, is available by default under Windows, and under Unix
+ * if PHP is compiled with the flag "--enable-bcmath". GMP requires the gmp
+ * library from http://www.swox.com/gmp/ and PHP compiled with the "--with-gmp"
+ * flag. BIG_INT support is available from a big_int PHP library available from
+ * only from PECL (a Windows port is not available).
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Math_BigInteger
+{
+
+    /**
+     * Holds an instance of one of the three arbitrary precision wrappers.
+     *
+     * @var Zend_Crypt_Math_BigInteger_Interface
+     */
+    protected $_math = null;
+
+    /**
+     * Constructor; a Factory which detects a suitable PHP extension for
+     * arbitrary precision math and instantiates the suitable wrapper
+     * object.
+     *
+     * @param string $extension
+     * @throws  Zend_Crypt_Math_BigInteger_Exception
+     */
+    public function __construct($extension = null)
+    {
+        if ($extension !== null && !in_array($extension, array('bcmath', 'gmp', 'bigint'))) {
+            throw new Zend_Crypt_Math_BigInteger_Exception('Invalid extension type; please use one of bcmath, gmp or bigint');
+        }
+        $this->_loadAdapter($extension);
+    }
+
+    /**
+     * Redirect all public method calls to the wrapped extension object.
+     *
+     * @param  string $methodName
+     * @param  array  $args
+     * @return mixed
+     * @throws Zend_Crypt_Math_BigInteger_Exception
+     */
+    public function __call($methodName, $args)
+    {
+        if(!method_exists($this->_math, $methodName)) {
+            throw new Zend_Crypt_Math_BigInteger_Exception('invalid method call: ' . get_class($this->_math) . '::' . $methodName . '() does not exist');
+        }
+        return call_user_func_array(array($this->_math, $methodName), $args);
+    }
+
+    /**
+     * @param string $extension
+     * @throws  Zend_Crypt_Math_BigInteger_Exception
+     */
+    protected function _loadAdapter($extension = null)
+    {
+        if ($extension === null) {
+            if (extension_loaded('gmp')) {
+                $extension = 'gmp';
+            //} elseif (extension_loaded('big_int')) {
+            //    $extension = 'big_int';
+            } else {
+                $extension = 'bcmath';
+            }
+        }
+        if($extension == 'gmp' && extension_loaded('gmp')) {
+            $this->_math = new Zend_Crypt_Math_BigInteger_Gmp();
+        //} elseif($extension == 'bigint' && extension_loaded('big_int')) {
+        //    require_once 'Zend/Crypt_Math/BigInteger/Bigint.php';
+        //    $this->_math = new Zend_Crypt_Math_BigInteger_Bigint();
+        } elseif ($extension == 'bcmath' && extension_loaded('bcmath')) {
+            $this->_math = new Zend_Crypt_Math_BigInteger_Bcmath();
+        } else {
+            throw new Zend_Crypt_Math_BigInteger_Exception($extension . ' big integer precision math support not detected');
+        }
+    }
+
+}
diff --git a/library/vendor/Zend/Crypt/Math/BigInteger/Bcmath.php b/library/vendor/Zend/Crypt/Math/BigInteger/Bcmath.php
new file mode 100644
index 0000000..2fb4a67
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Math/BigInteger/Bcmath.php
@@ -0,0 +1,226 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Math
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Math_BigInteger_Interface
+ */
+
+/**
+ * Support for arbitrary precision mathematics in PHP.
+ *
+ * Zend_Crypt_Math_BigInteger_Bcmath is a wrapper across the PHP BCMath
+ * extension.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Math_BigInteger_Bcmath implements Zend_Crypt_Math_BigInteger_Interface
+{
+
+    /**
+     * Initialise a big integer into an extension specific type. This is not
+     * applicable to BCMath.
+     *
+     * @param string $operand
+     * @param int $base
+     * @return string
+     */
+    public function init($operand, $base = 10)
+    {
+        return $operand;
+    }
+
+    /**
+     * Adds two arbitrary precision numbers
+     *
+     * @param string $left_operand
+     * @param string $right_operand
+     * @return string
+     */
+    public function add($left_operand, $right_operand)
+    {
+        return bcadd($left_operand, $right_operand);
+    }
+
+    /**
+     * Subtract one arbitrary precision number from another
+     *
+     * @param string $left_operand
+     * @param string $right_operand
+     * @return string
+     */
+    public function subtract($left_operand, $right_operand)
+    {
+        return bcsub($left_operand, $right_operand);
+    }
+
+    /**
+     * Compare two big integers and returns result as an integer where 0 means
+     * both are identical, 1 that left_operand is larger, or -1 that
+     * right_operand is larger.
+     *
+     * @param string $left_operand
+     * @param string $right_operand
+     * @return int
+     */
+    public function compare($left_operand, $right_operand)
+    {
+        return bccomp($left_operand, $right_operand);
+    }
+
+    /**
+     * Divide two big integers and return result or NULL if the denominator
+     * is zero.
+     *
+     * @param string $left_operand
+     * @param string $right_operand
+     * @return string|null
+     */
+    public function divide($left_operand, $right_operand)
+    {
+        return bcdiv($left_operand, $right_operand);
+    }
+
+    /**
+     * Get modulus of an arbitrary precision number
+     *
+     * @param string $left_operand
+     * @param string $modulus
+     * @return string
+     */
+    public function modulus($left_operand, $modulus)
+    {
+        return bcmod($left_operand, $modulus);
+    }
+
+    /**
+     * Multiply two arbitrary precision numbers
+     *
+     * @param string $left_operand
+     * @param string $right_operand
+     * @return string
+     */
+    public function multiply($left_operand, $right_operand)
+    {
+        return bcmul($left_operand, $right_operand);
+    }
+
+    /**
+     * Raise an arbitrary precision number to another
+     *
+     * @param string $left_operand
+     * @param string $right_operand
+     * @return string
+     */
+    public function pow($left_operand, $right_operand)
+    {
+        return bcpow($left_operand, $right_operand);
+    }
+
+    /**
+     * Raise an arbitrary precision number to another, reduced by a specified
+     * modulus
+     *
+     * @param string $left_operand
+     * @param string $right_operand
+     * @param string $modulus
+     * @return string
+     */
+    public function powmod($left_operand, $right_operand, $modulus)
+    {
+        return bcpowmod($left_operand, $right_operand, $modulus);
+    }
+
+    /**
+     * Get the square root of an arbitrary precision number
+     *
+     * @param string $operand
+     * @return string
+     */
+    public function sqrt($operand)
+    {
+        return bcsqrt($operand);
+    }
+
+    /**
+     * @param string $operand
+     * @return string
+     */
+    public function binaryToInteger($operand)
+    {
+        $result = '0';
+        while (strlen($operand)) {
+            $ord = ord(substr($operand, 0, 1));
+            $result = bcadd(bcmul($result, 256), $ord);
+            $operand = substr($operand, 1);
+        }
+        return $result;
+    }
+
+    /**
+     * @param string $operand
+     * @return string
+     */
+    public function integerToBinary($operand)
+    {
+        $cmp = bccomp($operand, 0);
+        $return = '';
+        if ($cmp == 0) {
+            return "\0";
+        }
+        while (bccomp($operand, 0) > 0) {
+            $return = chr(bcmod($operand, 256)) . $return;
+            $operand = bcdiv($operand, 256);
+        }
+        if (ord($return[0]) > 127) {
+            $return = "\0" . $return;
+        }
+        return $return;
+    }
+
+    /**public function integerToBinary($operand)
+    {
+        $return = '';
+        while(bccomp($operand, '0')) {
+            $return .= chr(bcmod($operand, '256'));
+            $operand = bcdiv($operand, '256');
+        }
+        return $return;
+    }**/ // Prior version for referenced offset
+
+    /**
+     * @param string $operand
+     * @return string
+     */
+    public function hexToDecimal($operand)
+    {
+        $return = '0';
+        while(strlen($hex)) {
+            $hex = hexdec(substr($operand, 0, 4));
+            $dec = bcadd(bcmul($return, 65536), $hex);
+            $operand = substr($operand, 4);
+        }
+        return $return;
+    }
+}
diff --git a/library/vendor/Zend/Crypt/Math/BigInteger/Exception.php b/library/vendor/Zend/Crypt/Math/BigInteger/Exception.php
new file mode 100644
index 0000000..c1c865d
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Math/BigInteger/Exception.php
@@ -0,0 +1,35 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Math
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Math_Exception
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Math_BigInteger_Exception extends Zend_Crypt_Math_Exception
+{
+}
diff --git a/library/vendor/Zend/Crypt/Math/BigInteger/Gmp.php b/library/vendor/Zend/Crypt/Math/BigInteger/Gmp.php
new file mode 100644
index 0000000..1912be7
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Math/BigInteger/Gmp.php
@@ -0,0 +1,219 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Math
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Math_BigInteger_Interface
+ */
+
+/**
+ * Support for arbitrary precision mathematics in PHP.
+ *
+ * Zend_Crypt_Math_BigInteger_Gmp is a wrapper across the PHP BCMath
+ * extension.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Math_BigInteger_Gmp implements Zend_Crypt_Math_BigInteger_Interface
+{
+
+    /**
+     * Initialise a big integer into an extension specific type.
+     * @param string $operand
+     * @param int $base
+     * @return string
+     */
+    public function init($operand, $base = 10)
+    {
+        return $operand;
+    }
+
+    /**
+     * Adds two arbitrary precision numbers
+     *
+     * @param resource $left_operand
+     * @param resource $right_operand
+     * @return string
+     */
+    public function add($left_operand, $right_operand)
+    {
+        $result = gmp_add($left_operand, $right_operand);
+        return gmp_strval($result);
+    }
+
+    /**
+     * Subtract numbers
+     *
+     * @param resource $left_operand
+     * @param resource $right_operand
+     * @return string
+     */
+    public function subtract($left_operand, $right_operand)
+    {
+        $result = gmp_sub($left_operand, $right_operand);
+        return gmp_strval($result);
+    }
+
+    /**
+     * Compare two big integers and returns result as an integer where 0 means
+     * both are identical, 1 that left_operand is larger, or -1 that
+     * right_operand is larger.
+     *
+     * @param resource $left_operand
+     * @param resource $right_operand
+     * @return int
+     */
+    public function compare($left_operand, $right_operand)
+    {
+        $result = gmp_cmp($left_operand, $right_operand);
+        return gmp_strval($result);
+    }
+
+    /**
+     * Divide two big integers and return result or NULL if the denominator
+     * is zero.
+     *
+     * @param resource $left_operand
+     * @param resource $right_operand
+     * @return string|null
+     */
+    public function divide($left_operand, $right_operand)
+    {
+        $result = gmp_div($left_operand, $right_operand);
+        return gmp_strval($result);
+    }
+
+    /**
+     * Modulo operation
+     *
+     * @param resource $left_operand
+     * @param resource $modulus
+     * @internal param string $right_operand
+     * @return string
+     */
+    public function modulus($left_operand, $modulus)
+    {
+        $result = gmp_mod($left_operand, $modulus);
+        return gmp_strval($result);
+    }
+
+    /**
+     * Multiply numbers
+     *
+     * @param resource $left_operand
+     * @param resource $right_operand
+     * @return string
+     */
+    public function multiply($left_operand, $right_operand)
+    {
+        $result = gmp_mul($left_operand, $right_operand);
+        return gmp_strval($result);
+    }
+
+    /**
+     * Raise number into power
+     *
+     * @param resource $left_operand
+     * @param int      $right_operand
+     * @return string
+     */
+    public function pow($left_operand, $right_operand)
+    {
+        $result = gmp_pow($left_operand, $right_operand);
+        return gmp_strval($result);
+    }
+
+    /**
+     * Raise number into power with modulo
+     *
+     * @param resource $left_operand
+     * @param resource $right_operand
+     * @param resource $modulus
+     * @return string
+     */
+    public function powmod($left_operand, $right_operand, $modulus)
+    {
+        $result = gmp_powm($left_operand, $right_operand, $modulus);
+        return gmp_strval($result);
+    }
+
+    /**
+     * Calculate square root
+     *
+     * @param $operand
+     * @return string
+     */
+    public function sqrt($operand)
+    {
+        $result = gmp_sqrt($operand);
+        return gmp_strval($result);
+    }
+
+    /**
+     * @param string $operand
+     * @return string
+     */
+    public function binaryToInteger($operand)
+    {
+        $result = '0';
+        while (strlen($operand)) {
+            $ord = ord(substr($operand, 0, 1));
+            $result = gmp_add(gmp_mul($result, 256), $ord);
+            $operand = substr($operand, 1);
+        }
+        return gmp_strval($result);
+    }
+
+    /**
+     * @param resource $operand GMP number resource
+     * @return string
+     */
+    public function integerToBinary($operand)
+    {
+        $bigInt = gmp_strval($operand, 16);
+        if (strlen($bigInt) % 2 != 0) {
+            $bigInt = '0' . $bigInt;
+        } else if ($bigInt[0] > '7') {
+            $bigInt = '00' . $bigInt;
+        }
+        $return = pack("H*", $bigInt);
+        return $return;
+    }
+
+    /**
+     * @param string $operand
+     * @return string
+     */
+    public function hexToDecimal($operand)
+    {
+        $return = '0';
+        while(strlen($hex)) {
+            $hex = hexdec(substr($operand, 0, 4));
+            $dec = gmp_add(gmp_mul($return, 65536), $hex);
+            $operand = substr($operand, 4);
+        }
+        return $return;
+    }
+
+}
diff --git a/library/vendor/Zend/Crypt/Math/BigInteger/Interface.php b/library/vendor/Zend/Crypt/Math/BigInteger/Interface.php
new file mode 100644
index 0000000..9fa9281
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Math/BigInteger/Interface.php
@@ -0,0 +1,51 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Math
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * Support for arbitrary precision mathematics in PHP.
+ *
+ * Interface for a wrapper across any PHP extension supporting arbitrary
+ * precision maths.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+interface Zend_Crypt_Math_BigInteger_Interface
+{
+
+    public function init($operand, $base = 10);
+    public function add($left_operand, $right_operand);
+    public function subtract($left_operand, $right_operand);
+    public function compare($left_operand, $right_operand);
+    public function divide($left_operand, $right_operand);
+    public function modulus($left_operand, $modulus);
+    public function multiply($left_operand, $right_operand);
+    public function pow($left_operand, $right_operand);
+    public function powmod($left_operand, $right_operand, $modulus);
+    public function sqrt($operand);
+    public function binaryToInteger($operand);
+    public function integerToBinary($operand);
+    public function hexToDecimal($operand);
+
+}
diff --git a/library/vendor/Zend/Crypt/Math/Exception.php b/library/vendor/Zend/Crypt/Math/Exception.php
new file mode 100644
index 0000000..066da03
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Math/Exception.php
@@ -0,0 +1,35 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Math
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Exception
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Math_Exception extends Zend_Crypt_Exception
+{
+}
diff --git a/library/vendor/Zend/Crypt/Rsa.php b/library/vendor/Zend/Crypt/Rsa.php
new file mode 100644
index 0000000..2523bbf
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Rsa.php
@@ -0,0 +1,334 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Rsa
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Rsa_Key_Private
+ */
+
+/**
+ * @see Zend_Crypt_Rsa_Key_Public
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Rsa
+{
+
+    const BINARY = 'binary';
+    const BASE64 = 'base64';
+
+    protected $_privateKey;
+
+    protected $_publicKey;
+
+    /**
+     * @var string
+     */
+    protected $_pemString;
+
+    protected $_pemPath;
+
+    protected $_certificateString;
+
+    protected $_certificatePath;
+
+    protected $_hashAlgorithm;
+
+    protected $_passPhrase;
+
+    /**
+     * Class constructor
+     *
+     * @param array $options
+     * @throws Zend_Crypt_Rsa_Exception
+     */
+    public function __construct(array $options = null)
+    {
+        if (!extension_loaded('openssl')) {
+            throw new Zend_Crypt_Rsa_Exception('Zend_Crypt_Rsa requires openssl extension to be loaded.');
+        }
+
+        // Set _hashAlgorithm property when we are sure, that openssl extension is loaded
+        // and OPENSSL_ALGO_SHA1 constant is available
+        $this->_hashAlgorithm = OPENSSL_ALGO_SHA1;
+
+        if (isset($options)) {
+            $this->setOptions($options);
+        }
+    }
+
+    public function setOptions(array $options)
+    {
+        if (isset($options['passPhrase'])) {
+            $this->_passPhrase = $options['passPhrase'];
+        }
+        foreach ($options as $option=>$value) {
+            switch ($option) {
+                case 'pemString':
+                    $this->setPemString($value);
+                    break;
+                case 'pemPath':
+                    $this->setPemPath($value);
+                    break;
+                case 'certificateString':
+                    $this->setCertificateString($value);
+                    break;
+                case 'certificatePath':
+                    $this->setCertificatePath($value);
+                    break;
+                case 'hashAlgorithm':
+                    $this->setHashAlgorithm($value);
+                    break;
+            }
+        }
+    }
+
+    public function getPrivateKey()
+    {
+        return $this->_privateKey;
+    }
+
+    public function getPublicKey()
+    {
+        return $this->_publicKey;
+    }
+
+    /**
+     * @param string $data
+     * @param Zend_Crypt_Rsa_Key_Private $privateKey
+     * @param string $format
+     * @return string
+     */
+    public function sign($data, Zend_Crypt_Rsa_Key_Private $privateKey = null, $format = null)
+    {
+        $signature = '';
+        if (isset($privateKey)) {
+            $opensslKeyResource = $privateKey->getOpensslKeyResource();
+        } else {
+            $opensslKeyResource = $this->_privateKey->getOpensslKeyResource();
+        }
+        $result = openssl_sign(
+            $data, $signature,
+            $opensslKeyResource,
+            $this->getHashAlgorithm()
+        );
+        if ($format == self::BASE64) {
+            return base64_encode($signature);
+        }
+        return $signature;
+    }
+
+    /**
+     * @param string $data
+     * @param string $signature
+     * @param string $format
+     * @return string
+     */
+    public function verifySignature($data, $signature, $format = null)
+    {
+        if ($format == self::BASE64) {
+            $signature = base64_decode($signature);
+        }
+        $result = openssl_verify($data, $signature,
+            $this->getPublicKey()->getOpensslKeyResource(),
+            $this->getHashAlgorithm());
+        return $result;
+    }
+
+    /**
+     * @param string $data
+     * @param Zend_Crypt_Rsa_Key $key
+     * @param string $format
+     * @return string
+     */
+    public function encrypt($data, Zend_Crypt_Rsa_Key $key, $format = null)
+    {
+        $encrypted = '';
+        $function = 'openssl_public_encrypt';
+        if ($key instanceof Zend_Crypt_Rsa_Key_Private) {
+            $function = 'openssl_private_encrypt';
+        }
+        $function($data, $encrypted, $key->getOpensslKeyResource());
+        if ($format == self::BASE64) {
+            return base64_encode($encrypted);
+        }
+        return $encrypted;
+    }
+
+    /**
+     * @param string $data
+     * @param Zend_Crypt_Rsa_Key $key
+     * @param string $format
+     * @return string
+     */
+    public function decrypt($data, Zend_Crypt_Rsa_Key $key, $format = null)
+    {
+        $decrypted = '';
+        if ($format == self::BASE64) {
+            $data = base64_decode($data);
+        }
+        $function = 'openssl_private_decrypt';
+        if ($key instanceof Zend_Crypt_Rsa_Key_Public) {
+            $function = 'openssl_public_decrypt';
+        }
+        $function($data, $decrypted, $key->getOpensslKeyResource());
+        return $decrypted;
+    }
+
+    /**
+     * @param  array $configargs
+     * 
+     * @throws Zend_Crypt_Rsa_Exception
+     * 
+     * @return ArrayObject
+     */
+    public function generateKeys(array $configargs = null)
+    {
+        $config = null;
+        $passPhrase = null;
+        if ($configargs !== null) {
+            if (isset($configargs['passPhrase'])) {
+                $passPhrase = $configargs['passPhrase'];
+                unset($configargs['passPhrase']);
+            }
+            $config = $this->_parseConfigArgs($configargs);
+        }
+        $privateKey = null;
+        $publicKey = null;
+        $resource = openssl_pkey_new($config);
+        if (!$resource) {
+            throw new Zend_Crypt_Rsa_Exception('Failed to generate a new private key');
+        }
+        // above fails on PHP 5.3
+        openssl_pkey_export($resource, $private, $passPhrase);
+        $privateKey = new Zend_Crypt_Rsa_Key_Private($private, $passPhrase);
+        $details = openssl_pkey_get_details($resource);
+        $publicKey = new Zend_Crypt_Rsa_Key_Public($details['key']);
+        $return = new ArrayObject(array(
+           'privateKey'=>$privateKey,
+           'publicKey'=>$publicKey
+        ), ArrayObject::ARRAY_AS_PROPS);
+        return $return;
+    }
+
+    /**
+     * @param string $value
+     */
+    public function setPemString($value)
+    {
+        $this->_pemString = $value;
+        try {
+            $this->_privateKey = new Zend_Crypt_Rsa_Key_Private($this->_pemString, $this->_passPhrase);
+            $this->_publicKey = $this->_privateKey->getPublicKey();
+        } catch (Zend_Crypt_Exception $e) {
+            $this->_privateKey = null;
+            $this->_publicKey = new Zend_Crypt_Rsa_Key_Public($this->_pemString);
+        }
+    }
+
+    public function setPemPath($value)
+    {
+        $this->_pemPath = $value;
+        $this->setPemString(file_get_contents($this->_pemPath));
+    }
+
+    public function setCertificateString($value)
+    {
+        $this->_certificateString = $value;
+        $this->_publicKey = new Zend_Crypt_Rsa_Key_Public($this->_certificateString, $this->_passPhrase);
+    }
+
+    public function setCertificatePath($value)
+    {
+        $this->_certificatePath = $value;
+        $this->setCertificateString(file_get_contents($this->_certificatePath));
+    }
+
+    public function setHashAlgorithm($name)
+    {
+        switch (strtolower($name)) {
+            case 'md2':
+                $this->_hashAlgorithm = OPENSSL_ALGO_MD2;
+                break;
+            case 'md4':
+                $this->_hashAlgorithm = OPENSSL_ALGO_MD4;
+                break;
+            case 'md5':
+                $this->_hashAlgorithm = OPENSSL_ALGO_MD5;
+                break;
+            case 'sha1':
+                $this->_hashAlgorithm = OPENSSL_ALGO_SHA1;
+                break;
+            case 'dss1':
+                $this->_hashAlgorithm = OPENSSL_ALGO_DSS1;
+                break;
+        }
+    }
+
+    /**
+     * @return string
+     */
+    public function getPemString()
+    {
+        return $this->_pemString;
+    }
+
+    public function getPemPath()
+    {
+        return $this->_pemPath;
+    }
+
+    public function getCertificateString()
+    {
+        return $this->_certificateString;
+    }
+
+    public function getCertificatePath()
+    {
+        return $this->_certificatePath;
+    }
+
+    public function getHashAlgorithm()
+    {
+        return $this->_hashAlgorithm;
+    }
+
+    protected function _parseConfigArgs(array $config = null)
+    {
+        $configs = array();
+        if (isset($config['private_key_bits'])) {
+            $configs['private_key_bits'] = $config['private_key_bits'];
+        }
+        if (isset($config['privateKeyBits'])) {
+            $configs['private_key_bits'] = $config['privateKeyBits'];
+        }
+        if (!empty($configs)) {
+            return $configs;
+        }
+        return null;
+    }
+
+}
diff --git a/library/vendor/Zend/Crypt/Rsa/Exception.php b/library/vendor/Zend/Crypt/Rsa/Exception.php
new file mode 100644
index 0000000..3b3944f
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Rsa/Exception.php
@@ -0,0 +1,35 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Math
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Exception.php 20096 2010-01-06 02:05:09Z bkarwin $
+ */
+
+/**
+ * @see Zend_Crypt_Exception
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Rsa_Exception extends Zend_Crypt_Exception
+{
+}
diff --git a/library/vendor/Zend/Crypt/Rsa/Key.php b/library/vendor/Zend/Crypt/Rsa/Key.php
new file mode 100644
index 0000000..cfd9d15
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Rsa/Key.php
@@ -0,0 +1,94 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Rsa
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Rsa_Key implements Countable
+{
+    /**
+     * @var string
+     */
+    protected $_pemString = null;
+
+    /**
+     * Bits, key string and type of key
+     *
+     * @var array
+     */
+    protected $_details = array();
+
+    /**
+     * Key Resource
+     *
+     * @var resource
+     */
+    protected $_opensslKeyResource = null;
+
+    /**
+     * Retrieves key resource
+     *
+     * @return resource
+     */
+    public function getOpensslKeyResource()
+    {
+        return $this->_opensslKeyResource;
+    }
+
+    /**
+     * @return string
+     * @throws Zend_Crypt_Exception
+     */
+    public function toString()
+    {
+        if (!empty($this->_pemString)) {
+            return $this->_pemString;
+        } elseif (!empty($this->_certificateString)) {
+            return $this->_certificateString;
+        }
+        /**
+         * @see Zend_Crypt_Exception
+         */
+        throw new Zend_Crypt_Exception('No public key string representation is available');
+    }
+
+    /**
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->toString();
+    }
+
+    public function count()
+    {
+        return $this->_details['bits'];
+    }
+
+    public function getType()
+    {
+        return $this->_details['type'];
+    }
+}
diff --git a/library/vendor/Zend/Crypt/Rsa/Key/Private.php b/library/vendor/Zend/Crypt/Rsa/Key/Private.php
new file mode 100644
index 0000000..b736b58
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Rsa/Key/Private.php
@@ -0,0 +1,72 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Rsa
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Rsa_Key
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Rsa_Key_Private extends Zend_Crypt_Rsa_Key
+{
+
+    protected $_publicKey = null;
+
+    public function __construct($pemString, $passPhrase = null)
+    {
+        $this->_pemString = $pemString;
+        $this->_parse($passPhrase);
+    }
+
+    /**
+     * @param string $passPhrase
+     * @throws Zend_Crypt_Exception
+     */
+    protected function _parse($passPhrase)
+    {
+        $result = openssl_get_privatekey($this->_pemString, $passPhrase);
+        if (!$result) {
+            /**
+             * @see Zend_Crypt_Exception
+             */
+            throw new Zend_Crypt_Exception('Unable to load private key');
+        }
+        $this->_opensslKeyResource = $result;
+        $this->_details = openssl_pkey_get_details($this->_opensslKeyResource);
+    }
+
+    public function getPublicKey()
+    {
+        if ($this->_publicKey === null) {
+            /**
+             * @see Zend_Crypt_Rsa_Key_Public
+             */
+            $this->_publicKey = new Zend_Crypt_Rsa_Key_Public($this->_details['key']);
+        }
+        return $this->_publicKey;
+    }
+
+}
diff --git a/library/vendor/Zend/Crypt/Rsa/Key/Public.php b/library/vendor/Zend/Crypt/Rsa/Key/Public.php
new file mode 100644
index 0000000..85b2eb6
--- /dev/null
+++ b/library/vendor/Zend/Crypt/Rsa/Key/Public.php
@@ -0,0 +1,72 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @subpackage Rsa
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * @see Zend_Crypt_Rsa_Key
+ */
+
+/**
+ * @category   Zend
+ * @package    Zend_Crypt
+ * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Crypt_Rsa_Key_Public extends Zend_Crypt_Rsa_Key
+{
+
+    protected $_certificateString = null;
+
+    public function __construct($string)
+    {
+        $this->_parse($string);
+    }
+
+    /**
+     * @param string $string
+     * @throws Zend_Crypt_Exception
+     */
+    protected function _parse($string)
+    {
+        if (preg_match("/^-----BEGIN CERTIFICATE-----/", $string)) {
+            $this->_certificateString = $string;
+        } else {
+            $this->_pemString = $string;
+        }
+        $result = openssl_get_publickey($string);
+        if (!$result) {
+            /**
+             * @see Zend_Crypt_Exception
+             */
+            throw new Zend_Crypt_Exception('Unable to load public key');
+        }
+        //openssl_pkey_export($result, $public);
+        //$this->_pemString = $public;
+        $this->_opensslKeyResource = $result;
+        $this->_details = openssl_pkey_get_details($this->_opensslKeyResource);
+    }
+
+    public function getCertificate()
+    {
+        return $this->_certificateString;
+    }
+
+}