/s3db3.5.10/pearlib/phpseclib/Crypt/RSA.php

Large files files are truncated, but you can click here to view the full file

<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */



/**

 * Pure-PHP PKCS#1 (v2.1) compliant implementation of RSA.

 *

 * PHP versions 4 and 5

 *

 * Here's an example of how to encrypt and decrypt text with this library:

 * <code>

 * <?php

 *    include('Crypt/RSA.php');

 *

 *    $rsa = new Crypt_RSA();

 *    extract($rsa->createKey());

 *

 *    $plaintext = 'terrafrost';

 *

 *    $rsa->loadKey($privatekey);

 *    $ciphertext = $rsa->encrypt($plaintext);

 *

 *    $rsa->loadKey($publickey);

 *    echo $rsa->decrypt($ciphertext);

 * 

 * </code>

 *

 * Here's an example of how to create signatures and verify signatures with this library:

 * <code>

 * <?php

 *    include('Crypt/RSA.php');

 *

 *    $rsa = new Crypt_RSA();

 *    extract($rsa->createKey());

 *

 *    $plaintext = 'terrafrost';

 *

 *    $rsa->loadKey($privatekey);

 *    $signature = $rsa->sign($plaintext);

 *

 *    $rsa->loadKey($publickey);

 *    echo $rsa->verify($plaintext, $signature) ? 'verified' : 'unverified';

 * 

 * </code>

 *

 * LICENSE: This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,

 * MA  02111-1307  USA

 *

 * @category   Crypt

 * @package    Crypt_RSA

 * @author     Jim Wigginton <terrafrost@php.net>

 * @copyright  MMIX Jim Wigginton

 * @license    http://www.gnu.org/licenses/lgpl.txt

 * @version    $Id: RSA.php,v 1.3 2009/12/04 21:05:32 terrafrost Exp $

 * @link       http://phpseclib.sourceforge.net

 */



/**

 * Include Math_BigInteger

 */

require_once('Math/BigInteger.php');



/**

 * Include Crypt_Random

 */

require_once('Crypt/Random.php');



/**

 * Include Crypt_Hash

 */

require_once('Crypt/Hash.php');



/**#@+

 * @access public

 * @see Crypt_RSA::encrypt()

 * @see Crypt_RSA::decrypt()

 */

/**

 * Use {@link http://en.wikipedia.org/wiki/Optimal_Asymmetric_Encryption_Padding Optimal Asymmetric Encryption Padding}

 * (OAEP) for encryption / decryption.

 *

 * Uses sha1 by default.

 *

 * @see Crypt_RSA::setHash()

 * @see Crypt_RSA::setMGFHash()

 */

define('CRYPT_RSA_ENCRYPTION_OAEP',  1);

/**

 * Use PKCS#1 padding.

 *

 * Although CRYPT_RSA_ENCRYPTION_OAEP offers more security, including PKCS#1 padding is necessary for purposes of backwards

 * compatability with protocols (like SSH-1) written before OAEP's introduction.

 */

define('CRYPT_RSA_ENCRYPTION_PKCS1', 2);

/**#@-*/



/**#@+

 * @access public

 * @see Crypt_RSA::sign()

 * @see Crypt_RSA::verify()

 * @see Crypt_RSA::setHash()

 */

/**

 * Use the Probabilistic Signature Scheme for signing

 *

 * Uses sha1 by default.

 *

 * @see Crypt_RSA::setSaltLength()

 * @see Crypt_RSA::setMGFHash()

 */

define('CRYPT_RSA_SIGNATURE_PSS',  1);

/**

 * Use the PKCS#1 scheme by default.

 *

 * Although CRYPT_RSA_SIGNATURE_PSS offers more security, including PKCS#1 signing is necessary for purposes of backwards

 * compatability with protocols (like SSH-2) written before PSS's introduction.

 */

define('CRYPT_RSA_SIGNATURE_PKCS1', 2);

/**#@-*/



/**#@+

 * @access private

 * @see Crypt_RSA::createKey()

 */

/**

 * ASN1 Integer

 */

define('CRYPT_RSA_ASN1_INTEGER',   2);

/**

 * ASN1 Sequence (with the constucted bit set)

 */

define('CRYPT_RSA_ASN1_SEQUENCE', 48);

/**#@-*/



/**#@+

 * @access private

 * @see Crypt_RSA::Crypt_RSA()

 */

/**

 * To use the pure-PHP implementation

 */

define('CRYPT_RSA_MODE_INTERNAL', 1);

/**

 * To use the OpenSSL library

 *

 * (if enabled; otherwise, the internal implementation will be used)

 */

define('CRYPT_RSA_MODE_OPENSSL', 2);

/**#@-*/



/**#@+

 * @access public

 * @see Crypt_RSA::createKey()

 * @see Crypt_RSA::setPrivateKeyFormat()

 */

/**

 * PKCS#1 formatted private key

 *

 * Used by OpenSSH

 */

define('CRYPT_RSA_PRIVATE_FORMAT_PKCS1', 0);

/**#@-*/



/**#@+

 * @access public

 * @see Crypt_RSA::createKey()

 * @see Crypt_RSA::setPublicKeyFormat()

 */

/**

 * Raw public key

 *

 * An array containing two Math_BigInteger objects.

 *

 * The exponent can be indexed with any of the following:

 *

 * 0, e, exponent, publicExponent

 *

 * The modulus can be indexed with any of the following:

 *

 * 1, n, modulo, modulus

 */

define('CRYPT_RSA_PUBLIC_FORMAT_RAW', 1);

/**

 * PKCS#1 formatted public key

 */

define('CRYPT_RSA_PUBLIC_FORMAT_PKCS1', 2);

/**

 * OpenSSH formatted public key

 *

 * Place in $HOME/.ssh/authorized_keys

 */

define('CRYPT_RSA_PUBLIC_FORMAT_OPENSSH', 3);

/**#@-*/



/**

 * Pure-PHP PKCS#1 compliant implementation of RSA.

 *

 * @author  Jim Wigginton <terrafrost@php.net>

 * @version 0.1.0

 * @access  public

 * @package Crypt_RSA

 */

class Crypt_RSA {

    /**

     * Precomputed Zero

     *

     * @var Array

     * @access private

     */

    var $zero;



    /**

     * Precomputed One

     *

     * @var Array

     * @access private

     */

    var $one;



    /**

     * Private Key Format

     *

     * @var Integer

     * @access private

     */

    var $privateKeyFormat = CRYPT_RSA_PRIVATE_FORMAT_PKCS1;



    /**

     * Public Key Format

     *

     * @var Integer

     * @access public

     */

    var $publicKeyFormat = CRYPT_RSA_PUBLIC_FORMAT_PKCS1;



    /**

     * Modulus (ie. n)

     *

     * @var Math_BigInteger

     * @access private

     */

    var $modulus;



    /**

     * Modulus length

     *

     * @var Math_BigInteger

     * @access private

     */

    var $k;



    /**

     * Exponent (ie. e or d)

     *

     * @var Math_BigInteger

     * @access private

     */

    var $exponent;



    /**

     * Primes for Chinese Remainder Theorem (ie. p and q)

     *

     * @var Array

     * @access private

     */

    var $primes;



    /**

     * Exponents for Chinese Remainder Theorem (ie. dP and dQ)

     *

     * @var Array

     * @access private

     */

    var $exponents;



    /**

     * Coefficients for Chinese Remainder Theorem (ie. qInv)

     *

     * @var Array

     * @access private

     */

    var $coefficients;



    /**

     * Hash name

     *

     * @var String

     * @access private

     */

    var $hashName;



    /**

     * Hash function

     *

     * @var Crypt_Hash

     * @access private

     */

    var $hash;



    /**

     * Length of hash function output

     *

     * @var Integer

     * @access private

     */

    var $hLen;



    /**

     * Length of salt

     *

     * @var Integer

     * @access private

     */

    var $sLen;



    /**

     * Hash function for the Mask Generation Function

     *

     * @var Crypt_Hash

     * @access private

     */

    var $mgfHash;



    /**

     * Encryption mode

     *

     * @var Integer

     * @access private

     */

    var $encryptionMode = CRYPT_RSA_ENCRYPTION_OAEP;



    /**

     * Signature mode

     *

     * @var Integer

     * @access private

     */

    var $signatureMode = CRYPT_RSA_SIGNATURE_PSS;



    /**

     * Public Exponent

     *

     * @var Mixed

     * @access private

     */

    var $publicExponent = false;



    /**

     * Password

     *

     * @var String

     * @access private

     */

    var $password = '';



    /**

     * The constructor

     *

     * If you want to make use of the openssl extension, you'll need to set the mode manually, yourself.  The reason

     * Crypt_RSA doesn't do it is because OpenSSL doesn't fail gracefully.  openssl_pkey_new(), in particular, requires

     * openssl.cnf be present somewhere and, unfortunately, the only real way to find out is too late.

     *

     * @return Crypt_RSA

     * @access public

     */

    function Crypt_RSA()

    {

        if ( !defined('CRYPT_RSA_MODE') ) {

            switch (true) {

                //case extension_loaded('openssl') && version_compare(PHP_VERSION, '4.2.0', '>='):

                //    define('CRYPT_RSA_MODE', CRYPT_RSA_MODE_OPENSSL);

                //    break;

                default:

                    define('CRYPT_RSA_MODE', CRYPT_RSA_MODE_INTERNAL);

            }

        }



        $this->zero = new Math_BigInteger();

        $this->one = new Math_BigInteger(1);



        $this->hash = new Crypt_Hash('sha1');

        $this->hLen = $this->hash->getLength();

        $this->hashName = 'sha1';

        $this->mgfHash = new Crypt_Hash('sha1');

    }



    /**

     * Create public / private key pair

     *

     * Returns an array with the following three elements:

     *  - 'privatekey': The private key.

     *  - 'publickey':  The public key.

     *  - 'partialkey': A partially computed key (if the execution time exceeded $timeout).

     *                  Will need to be passed back to Crypt_RSA::createKey() as the third parameter for further processing.

     *

     * @access public

     * @param optional Integer $bits

     * @param optional Integer $timeout

     * @param optional Math_BigInteger $p

     */

    function createKey($bits = 1024, $timeout = false, $primes = array())

    {

        if ( CRYPT_RSA_MODE == CRYPT_RSA_MODE_OPENSSL ) {

            $rsa = openssl_pkey_new(array('private_key_bits' => $bits));

            openssl_pkey_export($rsa, $privatekey);

            $publickey = openssl_pkey_get_details($rsa);

            $publickey = $publickey['key'];



            if ($this->privateKeyFormat != CRYPT_RSA_PRIVATE_FORMAT_PKCS1) {

                $privatekey = call_user_func_array(array($this, '_convertPrivateKey'), array_values($this->_parseKey($privatekey, CRYPT_RSA_PRIVATE_FORMAT_PKCS1)));

                $publickey = call_user_func_array(array($this, '_convertPublicKey'), array_values($this->_parseKey($publickey, CRYPT_RSA_PUBLIC_FORMAT_PKCS1)));

            }



            return array(

                'privatekey' => $privatekey,

                'publickey' => $publickey,

                'partialkey' => false

            );

        }



        static $e;

        if (!isset($e)) {

            if (!defined('CRYPT_RSA_EXPONENT')) {

                // http://en.wikipedia.org/wiki/65537_%28number%29

                define('CRYPT_RSA_EXPONENT', '65537');

            }

            if (!defined('CRYPT_RSA_COMMENT')) {

                define('CRYPT_RSA_COMMENT', 'phpseclib-generated-key');

            }

            // per <http://cseweb.ucsd.edu/~hovav/dist/survey.pdf#page=5>, this number ought not result in primes smaller

            // than 256 bits.

            if (!defined('CRYPT_RSA_SMALLEST_PRIME')) {

                define('CRYPT_RSA_SMALLEST_PRIME', 4096);

            }



            $e = new Math_BigInteger(CRYPT_RSA_EXPONENT);

        }



        extract($this->_generateMinMax($bits));

        $absoluteMin = $min;

        $temp = $bits >> 1;

        if ($temp > CRYPT_RSA_SMALLEST_PRIME) {

            $num_primes = floor($bits / CRYPT_RSA_SMALLEST_PRIME);

            $temp = CRYPT_RSA_SMALLEST_PRIME;

        } else {

            $num_primes = 2;

        }

        extract($this->_generateMinMax($temp + $bits % $temp));

        $finalMax = $max;

        extract($this->_generateMinMax($temp));



        $exponents = $coefficients = array();

        $generator = new Math_BigInteger();

        $generator->setRandomGenerator('crypt_random');



        $n = $this->one->copy();

        $lcm = array(

            'top' => $this->one->copy(),

            'bottom' => false

        );



        $start = time();

        $i0 = count($primes) + 1;



        do {

            for ($i = $i0; $i <= $num_primes; $i++) {

                if ($timeout !== false) {

                    $timeout-= time() - $start;

                    $start = time();

                    if ($timeout <= 0) {

                        return array(

                            'privatekey' => '',

                            'publickey'  => '',

                            'partialkey' => $primes

                        );

                    }

                }

                if ($i == $num_primes) {

                    list($min, $temp) = $absoluteMin->divide($n);

                    if (!$temp->equals($this->zero)) {

                        $min = $min->add($this->one); // ie. ceil()

                    }

                    $primes[$i] = $generator->randomPrime($min, $finalMax, $timeout);

                } else {

                    $primes[$i] = $generator->randomPrime($min, $max, $timeout);

                }



                if ($primes[$i] === false) { // if we've reached the timeout

                    return array(

                        'privatekey' => '',

                        'publickey'  => '',

                        'partialkey' => array_slice($primes, 0, $i - 1)

                    );

                }



                // the first coefficient is calculated differently from the rest

                // ie. instead of being $primes[1]->modInverse($primes[2]), it's $primes[2]->modInverse($primes[1])

                if ($i > 2) {

                    $coefficients[$i] = $n->modInverse($primes[$i]);

                }



                $n = $n->multiply($primes[$i]);



                $temp = $primes[$i]->subtract($this->one);



                // textbook RSA implementations use Euler's totient function instead of the least common multiple.

                // see http://en.wikipedia.org/wiki/Euler%27s_totient_function

                $lcm['top'] = $lcm['top']->multiply($temp);

                $lcm['bottom'] = $lcm['bottom'] === false ? $temp : $lcm['bottom']->gcd($temp);



                $exponents[$i] = $e->modInverse($temp);

            }



            list($lcm) = $lcm['top']->divide($lcm['bottom']);

            $gcd = $lcm->gcd($e);

            $i0 = 1;

        } while (!$gcd->equals($this->one));



        $d = $e->modInverse($lcm);



        $coefficients[2] = $primes[2]->modInverse($primes[1]);



        // from <http://tools.ietf.org/html/rfc3447#appendix-A.1.2>:

        // RSAPrivateKey ::= SEQUENCE {

        //     version           Version,

        //     modulus           INTEGER,  -- n

        //     publicExponent    INTEGER,  -- e

        //     privateExponent   INTEGER,  -- d

        //     prime1            INTEGER,  -- p

        //     prime2            INTEGER,  -- q

        //     exponent1         INTEGER,  -- d mod (p-1)

        //     exponent2         INTEGER,  -- d mod (q-1)

        //     coefficient       INTEGER,  -- (inverse of q) mod p

        //     otherPrimeInfos   OtherPrimeInfos OPTIONAL

        // }



        return array(

            'privatekey' => $this->_convertPrivateKey($n, $e, $d, $primes, $exponents, $coefficients),

            'publickey'  => $this->_convertPublicKey($n, $e),

            'partialkey' => false

        );

    }



    /**

     * Convert a private key to the appropriate format.

     *

     * @access private

     * @see setPrivateKeyFormat()

     * @param String $RSAPrivateKey

     * @return String

     */

    function _convertPrivateKey($n, $e, $d, $primes, $exponents, $coefficients)

    {

        $num_primes = count($primes);



        $raw = array(

            'version' => $num_primes == 2 ? chr(0) : chr(1), // two-prime vs. multi

            'modulus' => $n->toBytes(true),

            'publicExponent' => $e->toBytes(true),

            'privateExponent' => $d->toBytes(true),

            'prime1' => $primes[1]->toBytes(true),

            'prime2' => $primes[2]->toBytes(true),

            'exponent1' => $exponents[1]->toBytes(true),

            'exponent2' => $exponents[2]->toBytes(true),

            'coefficient' => $coefficients[2]->toBytes(true)

        );



        // if the format in question does not support multi-prime rsa and multi-prime rsa was used,

        // call _convertPublicKey() instead.

        switch ($this->privateKeyFormat) {

            default: // eg. CRYPT_RSA_PRIVATE_FORMAT_PKCS1

                $components = array();

                foreach ($raw as $name => $value) {

                    $components[$name] = pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($value)), $value);

                }



                $RSAPrivateKey = implode('', $components);



                if ($num_primes > 2) {

                    $OtherPrimeInfos = '';

                    for ($i = 3; $i <= $num_primes; $i++) {

                        // OtherPrimeInfos ::= SEQUENCE SIZE(1..MAX) OF OtherPrimeInfo

                        //

                        // OtherPrimeInfo ::= SEQUENCE {

                        //     prime             INTEGER,  -- ri

                        //     exponent          INTEGER,  -- di

                        //     coefficient       INTEGER   -- ti

                        // }

                        $OtherPrimeInfo = pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($primes[$i]->toBytes(true))), $primes[$i]->toBytes(true));

                        $OtherPrimeInfo.= pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($exponents[$i]->toBytes(true))), $exponents[$i]->toBytes(true));

                        $OtherPrimeInfo.= pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($coefficients[$i]->toBytes(true))), $coefficients[$i]->toBytes(true));

                        $OtherPrimeInfos.= pack('Ca*a*', CRYPT_RSA_ASN1_SEQUENCE, $this->_encodeLength(strlen($OtherPrimeInfo)), $OtherPrimeInfo);

                    }

                    $RSAPrivateKey.= pack('Ca*a*', CRYPT_RSA_ASN1_SEQUENCE, $this->_encodeLength(strlen($OtherPrimeInfos)), $OtherPrimeInfos);

                }



                $RSAPrivateKey = pack('Ca*a*', CRYPT_RSA_ASN1_SEQUENCE, $this->_encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);



                if (!empty($this->password)) {

                    $iv = $this->_random(8);

                    $symkey = pack('H*', md5($this->password . $iv)); // symkey is short for symmetric key

                    $symkey.= substr(pack('H*', md5($symkey . $this->password . $iv)), 0, 8);

                    if (!class_exists('Crypt_TripleDES')) {

                        require_once('Crypt/TripleDES.php');

                    }

                    $des = new Crypt_TripleDES();

                    $des->setKey($symkey);

                    $des->setIV($iv);

                    $iv = strtoupper(bin2hex($iv));

                    $RSAPrivateKey = "-----BEGIN RSA PRIVATE KEY-----\r\n" .

                                     "Proc-Type: 4,ENCRYPTED\r\n" .

                                     "DEK-Info: DES-EDE3-CBC,$iv\r\n" .

                                     "\r\n" .

                                     chunk_split(base64_encode($des->encrypt($RSAPrivateKey))) .

                                     '-----END RSA PRIVATE KEY-----';

                } else {

                    $RSAPrivateKey = "-----BEGIN RSA PRIVATE KEY-----\r\n" .

                                     chunk_split(base64_encode($RSAPrivateKey)) .

                                     '-----END RSA PRIVATE KEY-----';

                }



                return $RSAPrivateKey;

        }

    }



    /**

     * Convert a public key to the appropriate format

     *

     * @access private

     * @see setPublicKeyFormat()

     * @param String $RSAPrivateKey

     * @return String

     */

    function _convertPublicKey($n, $e)

    {

        $modulus = $n->toBytes(true);

        $publicExponent = $e->toBytes(true);



        switch ($this->publicKeyFormat) {

            case CRYPT_RSA_PUBLIC_FORMAT_RAW:

                return array('e' => $e->copy(), 'n' => $n->copy());

            case CRYPT_RSA_PUBLIC_FORMAT_OPENSSH:

                // from <http://tools.ietf.org/html/rfc4253#page-15>:

                // string    "ssh-rsa"

                // mpint     e

                // mpint     n

                $RSAPublicKey = pack('Na*Na*Na*', strlen('ssh-rsa'), 'ssh-rsa', strlen($publicExponent), $publicExponent, strlen($modulus), $modulus);

                $RSAPublicKey = 'ssh-rsa ' . base64_encode($RSAPublicKey) . ' ' . CRYPT_RSA_COMMENT;



                return $RSAPublicKey;

            default: // eg. CRYPT_RSA_PUBLIC_FORMAT_PKCS1

                // from <http://tools.ietf.org/html/rfc3447#appendix-A.1.1>:

                // RSAPublicKey ::= SEQUENCE {

                //     modulus           INTEGER,  -- n

                //     publicExponent    INTEGER   -- e

                // }

                $components = array(

                    'modulus' => pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($modulus)), $modulus),

                    'publicExponent' => pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($publicExponent)), $publicExponent)

                );



                $RSAPublicKey = pack('Ca*a*a*',

                    CRYPT_RSA_ASN1_SEQUENCE, $this->_encodeLength(strlen($components['modulus']) + strlen($components['publicExponent'])),

                    $components['modulus'], $components['publicExponent']

                );



                $RSAPublicKey = "-----BEGIN PUBLIC KEY-----\r\n" .

                                 chunk_split(base64_encode($RSAPublicKey)) .

                                 '-----END PUBLIC KEY-----';



                return $RSAPublicKey;

        }

    }



    /**

     * Break a public or private key down into its constituant components

     *

     * @access private

     * @see _convertPublicKey()

     * @see _convertPrivateKey()

     * @param String $key

     * @param Integer $type

     * @return Array

     */

    function _parseKey($key, $type)

    {

        switch ($type) {

            case CRYPT_RSA_PUBLIC_FORMAT_RAW:

                if (!is_array($key)) {

                    return false;

                }

                $components = array();

                switch (true) {

                    case isset($key['e']):

                        $components['publicExponent'] = $key['e']->copy();

                        break;

                    case isset($key['exponent']):

                        $components['publicExponent'] = $key['exponent']->copy();

                        break;

                    case isset($key['publicExponent']):

                        $components['publicExponent'] = $key['publicExponent']->copy();

                        break;

                    case isset($key[0]):

                        $components['publicExponent'] = $key[0]->copy();

                }

                switch (true) {

                    case isset($key['n']):

                        $components['modulus'] = $key['n']->copy();

                        break;

                    case isset($key['modulo']):

                        $components['modulus'] = $key['modulo']->copy();

                        break;

                    case isset($key['modulus']):

                        $components['modulus'] = $key['modulus']->copy();

                        break;

                    case isset($key[1]):

                        $components['modulus'] = $key[1]->copy();

                }

                return $components;

            case CRYPT_RSA_PRIVATE_FORMAT_PKCS1:

            case CRYPT_RSA_PUBLIC_FORMAT_PKCS1:

                /* Although PKCS#1 proposes a format that public and private keys can use, encrypting them is

                   "outside the scope" of PKCS#1.  PKCS#1 then refers you to PKCS#12 and PKCS#15 if you're wanting to

                   protect private keys, however, that's not what OpenSSL* does.  OpenSSL protects private keys by adding

                   two new "fields" to the key - DEK-Info and Proc-Type.  These fields are discussed here:



                   http://tools.ietf.org/html/rfc1421#section-4.6.1.1

                   http://tools.ietf.org/html/rfc1421#section-4.6.1.3



                   DES-EDE3-CBC as an algorithm, however, is not discussed anywhere, near as I can tell.

                   DES-CBC and DES-EDE are discussed in RFC1423, however, DES-EDE3-CBC isn't, nor is its key derivation

                   function.  As is, the definitive authority on this encoding scheme isn't the IETF but rather OpenSSL's

                   own implementation.  ie. the implementation *is* the standard and any bugs that may exist in that 

                   implementation are part of the standard, as well.



                   * OpenSSL is the de facto standard.  It's utilized by OpenSSH and other projects */

                if (preg_match('#DEK-Info: DES-EDE3-CBC,(.+)#', $key, $matches)) {

                    $iv = pack('H*', trim($matches[1]));

                    $symkey = pack('H*', md5($this->password . $iv)); // symkey is short for symmetric key

                    $symkey.= substr(pack('H*', md5($symkey . $this->password . $iv)), 0, 8);

                    $ciphertext = base64_decode(preg_replace('#.+(\r|\n|\r\n)\1|[\r\n]|-.+-#s', '', $key));

                    if ($ciphertext === false) {

                        return false;

                    }

                    if (!class_exists('Crypt_TripleDES')) {

                        require_once('Crypt/TripleDES.php');

                    }

                    $des = new Crypt_TripleDES();

                    $des->setKey($symkey);

                    $des->setIV($iv);

                    $key = $des->decrypt($ciphertext);

                } else {

                    $key = base64_decode(preg_replace('#-.+-|[\r\n]#', '', $key));

                    if ($key === false) {

                        return false;

                    }

                }



                $private = false;

                $components = array();



                $this->_string_shift($key); // skip over CRYPT_RSA_ASN1_SEQUENCE

                $this->_decodeLength($key); // skip over the length of the above sequence

                $this->_string_shift($key); // skip over CRYPT_RSA_ASN1_INTEGER

                $length = $this->_decodeLength($key);

                $temp = $this->_string_shift($key, $length);

                if (strlen($temp) != 1 || ord($temp) > 2) {

                    $components['modulus'] = new Math_BigInteger($temp, -256);

                    $this->_string_shift($key); // skip over CRYPT_RSA_ASN1_INTEGER

                    $length = $this->_decodeLength($key);

                    $components[$type == CRYPT_RSA_PUBLIC_FORMAT_PKCS1 ? 'publicExponent' : 'privateExponent'] = new Math_BigInteger($this->_string_shift($key, $length), -256);



                    return $components;

                }

                $this->_string_shift($key); // skip over CRYPT_RSA_ASN1_INTEGER

                $length = $this->_decodeLength($key);

                $components['modulus'] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                $this->_string_shift($key);

                $length = $this->_decodeLength($key);

                $components['publicExponent'] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                $this->_string_shift($key);

                $length = $this->_decodeLength($key);

                $components['privateExponent'] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                $this->_string_shift($key);

                $length = $this->_decodeLength($key);

                $components['primes'] = array(1 => new Math_BigInteger($this->_string_shift($key, $length), -256));

                $this->_string_shift($key);

                $length = $this->_decodeLength($key);

                $components['primes'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                $this->_string_shift($key);

                $length = $this->_decodeLength($key);

                $components['exponents'] = array(1 => new Math_BigInteger($this->_string_shift($key, $length), -256));

                $this->_string_shift($key);

                $length = $this->_decodeLength($key);

                $components['exponents'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                $this->_string_shift($key);

                $length = $this->_decodeLength($key);

                $components['coefficients'] = array(2 => new Math_BigInteger($this->_string_shift($key, $length), -256));

                if (!empty($key)) {

                    $key = substr($key, 1); // skip over CRYPT_RSA_ASN1_SEQUENCE

                    $this->_decodeLength($key);

                    while (!empty($key)) {

                        $key = substr($key, 1); // skip over CRYPT_RSA_ASN1_SEQUENCE

                        $this->_decodeLength($key);

                        $key = substr($key, 1);

                        $length = $this->_decodeLength($key);

                        $components['primes'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                        $this->_string_shift($key);

                        $length = $this->_decodeLength($key);

                        $components['exponents'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                        $this->_string_shift($key);

                        $length = $this->_decodeLength($key);

                        $components['coefficients'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                    }

                }



                return $components;

            case CRYPT_RSA_PUBLIC_FORMAT_OPENSSH:

                $key = base64_decode(preg_replace('#^ssh-rsa | .+$#', '', $key));

                if ($key === false) {

                    return false;

                }



                $components = array();

                extract(unpack('Nlength', $this->_string_shift($key, 4)));

                $components['modulus'] = new Math_BigInteger($this->_string_shift($key, $length), -256);

                extract(unpack('Nlength', $this->_string_shift($key, 4)));

                $components['publicExponent'] = new Math_BigInteger($this->_string_shift($key, $length), -256);



                return $components;

        }

    }



    /**

     * Loads a public or private key

     *

     * @access public

     * @param String $key

     * @param Integer $type optional

     */

    function loadKey($key, $type = CRYPT_RSA_PRIVATE_FORMAT_PKCS1)

    {

        $components = $this->_parseKey($key, $type);

        $this->modulus = $components['modulus'];

        $this->k = strlen($this->modulus->toBytes());

        $this->exponent = isset($components['privateExponent']) ? $components['privateExponent'] : $components['publicExponent'];

        if (isset($components['primes'])) {

            $this->primes = $components['primes'];

            $this->exponents = $components['exponents'];

            $this->coefficients = $components['coefficients'];

            $this->publicExponent = $components['publicExponent'];

        } else {

            $this->primes = array();

            $this->exponents = array();

            $this->coefficients = array();

            $this->publicExponent = false;

        }

    }



    /**

     * Sets the password

     *

     * Private keys can be encrypted with a password.  To unset the password, pass in the empty string or false.

     * Or rather, pass in $password such that empty($password) is true.

     *

     * @see createKey()

     * @see loadKey()

     * @access public

     * @param String $password

     */

    function setPassword($password)

    {

        $this->password = $password;

    }



    /**

     * Defines the public key

     *

     * Some private key formats define the public exponent and some don't.  Those that don't define it are problematic when

     * used in certain contexts.  For example, in SSH-2, RSA authentication works by sending the public key along with a

     * message signed by the private key to the server.  The SSH-2 server looks the public key up in an index of public keys

     * and if it's present then proceeds to verify the signature.  Problem is, if your private key doesn't include the public

     * exponent this won't work unless you manually add the public exponent.

     *

     * Do note that when a new key is loaded the index will be cleared.

     *

     * Returns true on success, false on failure

     *

     * @see getPublicKey()

     * @access public

     * @param String $key

     * @param Integer $type optional

     * @return Boolean

     */

    function setPublicKey($key, $type = CRYPT_RSA_PUBLIC_FORMAT_PKCS1)

    {

        $components = $this->_parseKey($key, $type);

        if (!$this->modulus->equals($components['modulus'])) {

            return false;

        }

        $this->publicExponent = $components['publicExponent'];

    }



    /**

     * Returns the public key

     *

     * The public key is only returned under two circumstances - if the private key had the public key embedded within it

     * or if the public key was set via setPublicKey().  If the currently loaded key is supposed to be the public key this

     * function won't return it since this library, for the most part, doesn't distinguish between public and private keys.

     *

     * @see getPublicKey()

     * @access public

     * @param String $key

     * @param Integer $type optional

     */

    function getPublicKey($type = CRYPT_RSA_PUBLIC_FORMAT_PKCS1)

    {

        $oldFormat = $this->publicKeyFormat;

        $this->publicKeyFormat = $type;

        $temp = $this->_convertPublicKey($this->modulus, $this->publicExponent);

        $this->publicKeyFormat = $oldFormat;

        return $temp;

    }



    /**

     * Generates the smallest and largest numbers requiring $bits bits

     *

     * @access private

     * @param Integer $bits

     * @return Array

     */

    function _generateMinMax($bits)

    {

        $bytes = $bits >> 3;

        $min = str_repeat(chr(0), $bytes);

        $max = str_repeat(chr(0xFF), $bytes);

        $msb = $num_bits & 7;

        if ($msb) {

            $min = chr(1 << ($msb - 1)) . $min;

            $max = chr((1 << $msb) - 1) . $max;

        } else {

            $min[0] = chr(0x80);

        }



        return array(

            'min' => new Math_BigInteger($min, 256),

            'max' => new Math_BigInteger($max, 256)

        );

    }



    /**

     * DER-decode the length

     *

     * DER supports lengths up to (2**8)**127, however, we'll only support lengths up to (2**8)**4.  See

     * {@link http://itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf#p=13 X.690 § 8.1.3} for more information.

     *

     * @access private

     * @param String $string

     * @return Integer

     */

    function _decodeLength(&$string)

    {

        $length = ord($this->_string_shift($string));

        if ( $length & 0x80 ) { // definite length, long form

            $length&= 0x7F;

            $temp = $this->_string_shift($string, $length);

            $start+= $length;

            list(, $length) = unpack('N', substr(str_pad($temp, 4, chr(0), STR_PAD_LEFT), -4));

        }

        return $length;

    }



    /**

     * DER-encode the length

     *

     * DER supports lengths up to (2**8)**127, however, we'll only support lengths up to (2**8)**4.  See

     * {@link http://itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf#p=13 X.690 § 8.1.3} for more information.

     *

     * @access private

     * @param Integer $length

     * @return String

     */

    function _encodeLength($length)

    {

        if ($length <= 0x7F) {

            return chr($length);

        }



        $temp = ltrim(pack('N', $length), chr(0));

        return pack('Ca*', 0x80 | strlen($temp), $temp);

    }



    /**

     * String Shift

     *

     * Inspired by array_shift

     *

     * @param String $string

     * @param optional Integer $index

     * @return String

     * @access private

     */

    function _string_shift(&$string, $index = 1)

    {

        $substr = substr($string, 0, $index);

        $string = substr($string, $index);

        return $substr;

    }



    /**

     * Determines the private key format

     *

     * @see createKey()

     * @access public

     * @param Integer $format

     */

    function setPrivateKeyFormat($format)

    {

        $this->privateKeyFormat = $format;

    }



    /**

     * Determines the public key format

     *

     * @see createKey()

     * @access public

     * @param Integer $format

     */

    function setPublicKeyFormat($format)

    {

        $this->publicKeyFormat = $format;

    }



    /**

     * Determines which hashing function should be used

     *

     * Used with signature production / verification and (if the encryption mode is CRYPT_RSA_ENCRYPTION_OAEP) encryption and

     * decryption.  If $hash isn't supported, sha1 is used.

     *

     * @access public

     * @param String $hash

     */

    function setHash($hash)

    {

        // Crypt_Hash supports algorithms that PKCS#1 doesn't support.  md5-96 and sha1-96, for example.

        switch ($hash) {

            case 'md2':

            case 'md5':

            case 'sha1':

            case 'sha256':

            case 'sha384':

            case 'sha512':

                $this->hash = new Crypt_Hash($hash);

                $this->hLen = $this->hash->getLength();

                $this->hashName = $hash;

                break;

            default:

                $this->hash = new Crypt_Hash('sha1');

                $this->hLen = $this->hash->getLength();

                $this->hashName = 'sha1';

        }

    }



    /**

     * Determines which hashing function should be used for the mask generation function

     *

     * The mask generation function is used by CRYPT_RSA_ENCRYPTION_OAEP and CRYPT_RSA_SIGNATURE_PSS and although it's

     * best if Hash and MGFHash are set to the same thing this is not a requirement.

     *

     * @access public

     * @param String $hash

     */

    function setMGFHash($hash)

    {

        // Crypt_Hash supports algorithms that PKCS#1 doesn't support.  md5-96 and sha1-96, for example.

        switch ($hash) {

            case 'md2':

            case 'md5':

            case 'sha1':

            case 'sha256':

            case 'sha384':

            case 'sha512':

                $this->mgfHash = new Crypt_Hash($hash);

                break;

            default:

                $this->mgfHash = new Crypt_Hash('sha1');

        }

    }



    /**

     * Determines the salt length

     *

     * To quote from {@link http://tools.ietf.org/html/rfc3447#page-38 RFC3447#page-38}:

     *

     *    Typical salt lengths in octets are hLen (the length of the output

     *    of the hash function Hash) and 0.

     *

     * @access public

     * @param Integer $format

     */

    function setSaltLength($sLen)

    {

        $this->sLen = $sLen;

    }



    /**

     * Generates a random string x bytes long

     *

     * @access public

     * @param Integer $bytes

     * @param optional Integer $nonzero

     * @return String

     */

    function _random($bytes, $nonzero = false)

    {

        $temp = '';

        if ($nonzero) {

            for ($i = 0; $i < $bytes; $i++) {

                $temp.= chr(crypt_random(1, 255));

            }

        } else {

            $ints = ($bytes + 1) >> 2;

            for ($i = 0; $i < $ints; $i++) {

                $temp.= pack('N', crypt_random());

            }

            $temp = substr($temp, 0, $bytes);

        }

        return $temp;

    }



    /**

     * Integer-to-Octet-String primitive

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-4.1 RFC3447#section-4.1}.

     *

     * @access private

     * @param Math_BigInteger $x

     * @param Integer $xLen

     * @return String

     */

    function _i2osp($x, $xLen)

    {

        $x = $x->toBytes();

        if (strlen($x) > $xLen) {

            user_error('Integer too large', E_USER_NOTICE);

            return false;

        }

        return str_pad($x, $xLen, chr(0), STR_PAD_LEFT);

    }



    /**

     * Octet-String-to-Integer primitive

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-4.2 RFC3447#section-4.2}.

     *

     * @access private

     * @param String $x

     * @return Math_BigInteger

     */

    function _os2ip($x)

    {

        return new Math_BigInteger($x, 256);

    }



    /**

     * Exponentiate with or without Chinese Remainder Theorem

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-5.1.1 RFC3447#section-5.1.2}.

     *

     * @access private

     * @param Math_BigInteger $x

     * @return Math_BigInteger

     */

    function _exponentiate($x)

    {

        if (empty($this->primes) || empty($this->coefficients) || empty($this->exponents)) {

            return $x->modPow($this->exponent, $this->modulus);

        }



        $num_primes = count($this->primes);

        $m_i = array(

            1 => $x->modPow($this->exponents[1], $this->primes[1]),

            2 => $x->modPow($this->exponents[2], $this->primes[2])

        );

        $h = $m_i[1]->subtract($m_i[2]);

        $h = $h->multiply($this->coefficients[2]);

        list(, $h) = $h->divide($this->primes[1]);

        $m = $m_i[2]->add($h->multiply($this->primes[2]));



        $r = $this->primes[1];

        for ($i = 3; $i <= $num_primes; $i++) {

            $m_i = $x->modPow($this->exponents[$i], $this->primes[$i]);



            $r = $r->multiply($this->primes[$i - 1]);



            $h = $m_i->subtract($m);

            $h = $h->multiply($this->coefficients[$i]);

            list(, $h) = $h->divide($this->primes[$i]);



            $m = $m->add($r->multiply($h));

        }



        return $m;

    }



    /**

     * RSAEP

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-5.1.1 RFC3447#section-5.1.1}.

     *

     * @access private

     * @param Math_BigInteger $m

     * @return Math_BigInteger

     */

    function _rsaep($m)

    {

        if ($m->compare($this->zero) < 0 || $m->compare($this->modulus) > 0) {

            user_error('Message representative out of range', E_USER_NOTICE);

            return false;

        }

        return $this->_exponentiate($m);

    }



    /**

     * RSADP

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-5.1.2 RFC3447#section-5.1.2}.

     *

     * @access private

     * @param Math_BigInteger $c

     * @return Math_BigInteger

     */

    function _rsadp($c)

    {

        if ($c->compare($this->zero) < 0 || $c->compare($this->modulus) > 0) {

            user_error('Ciphertext representative out of range', E_USER_NOTICE);

            return false;

        }

        return $this->_exponentiate($c);

    }



    /**

     * RSASP1

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-5.2.1 RFC3447#section-5.2.1}.

     *

     * @access private

     * @param Math_BigInteger $m

     * @return Math_BigInteger

     */

    function _rsasp1($m)

    {

        if ($m->compare($this->zero) < 0 || $m->compare($this->modulus) > 0) {

            user_error('Message representative out of range', E_USER_NOTICE);

            return false;

        }

        return $this->_exponentiate($m);

    }



    /**

     * RSAVP1

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-5.2.2 RFC3447#section-5.2.2}.

     *

     * @access private

     * @param Math_BigInteger $s

     * @return Math_BigInteger

     */

    function _rsavp1($s)

    {

        if ($s->compare($this->zero) < 0 || $s->compare($this->modulus) > 0) {

            user_error('Signature representative out of range', E_USER_NOTICE);

            return false;

        }

        return $this->_exponentiate($s);

    }



    /**

     * MGF1

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-B.2.1 RFC3447#section-B.2.1}.

     *

     * @access private

     * @param String $mgfSeed

     * @param Integer $mgfLen

     * @return String

     */

    function _mgf1($mgfSeed, $maskLen)

    {

        // if $maskLen would yield strings larger than 4GB, PKCS#1 suggests a "Mask too long" error be output.



        $t = '';

        $count = ceil($maskLen / $this->hLen);

        for ($i = 0; $i < $count; $i++) {

            $c = pack('N', $i);

            $t.= $this->mgfHash->hash($mgfSeed . $c);

        }



        return substr($t, 0, $maskLen);

    }



    /**

     * RSAES-OAEP-ENCRYPT

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-7.1.1 RFC3447#section-7.1.1} and

     * {http://en.wikipedia.org/wiki/Optimal_Asymmetric_Encryption_Padding OAES}.

     *

     * @access private

     * @param String $m

     * @param String $l

     * @return String

     */

    function _rsaes_oaep_encrypt($m, $l = '')

    {

        $mLen = strlen($m);



        // Length checking



        // if $l is larger than two million terrabytes and you're using sha1, PKCS#1 suggests a "Label too long" error

        // be output.



        if ($mLen > $this->k - 2 * $this->hLen - 2) {

            user_error('Message too long', E_USER_NOTICE);

            return false;

        }



        // EME-OAEP encoding



        $lHash = $this->hash->hash($l);

        $ps = str_repeat(chr(0), $this->k - $mLen - 2 * $this->hLen - 2);

        $db = $lHash . $ps . chr(1) . $m;

        $seed = $this->_random($this->hLen);

        $dbMask = $this->_mgf1($seed, $this->k - $this->hLen - 1);

        $maskedDB = $db ^ $dbMask;

        $seedMask = $this->_mgf1($maskedDB, $this->hLen);

        $maskedSeed = $seed ^ $seedMask;

        $em = chr(0) . $maskedSeed . $maskedDB;



        // RSA encryption



        $m = $this->_os2ip($em);

        $c = $this->_rsaep($m);

        $c = $this->_i2osp($c, $this->k);



        // Output the ciphertext C



        return $c;

    }



    /**

     * RSAES-OAEP-DECRYPT

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-7.1.2 RFC3447#section-7.1.2}.  The fact that the error

     * messages aren't distinguishable from one another hinders debugging, but, to quote from RFC3447#section-7.1.2:

     * 

     *    Note.  Care must be taken to ensure that an opponent cannot

     *    distinguish the different error conditions in Step 3.g, whether by

     *    error message or timing, or, more generally, learn partial

     *    information about the encoded message EM.  Otherwise an opponent may

     *    be able to obtain useful information about the decryption of the

     *    ciphertext C, leading to a chosen-ciphertext attack such as the one

     *    observed by Manger [36].

     *

     * As for $l...  to quote from {@link http://tools.ietf.org/html/rfc3447#page-17 RFC3447#page-17}:

     *

     *    Both the encryption and the decryption operations of RSAES-OAEP take

     *    the value of a label L as input.  In this version of PKCS #1, L is

     *    the empty string; other uses of the label are outside the scope of

     *    this document.

     *

     * @access private

     * @param String $c

     * @param String $l

     * @return String

     */

    function _rsaes_oaep_decrypt($c, $l = '')

    {

        // Length checking



        // if $l is larger than two million terrabytes and you're using sha1, PKCS#1 suggests a "Label too long" error

        // be output.



        if (strlen($c) != $this->k || $this->k < 2 * $this->hLen + 2) {

            user_error('Decryption error', E_USER_NOTICE);

            return false;

        }



        // RSA decryption



        $c = $this->_os2ip($c);

        $m = $this->_rsadp($c);

        if ($m === false) {

            user_error('Decryption error', E_USER_NOTICE);

            return false;

        }

        $em = $this->_i2osp($m, $this->k);



        // EME-OAEP decoding



        $lHash = $this->hash->hash($l);

        $y = ord($em[0]);

        $maskedSeed = substr($em, 1, $this->hLen);

        $maskedDB = substr($em, $this->hLen + 1);

        $seedMask = $this->_mgf1($maskedDB, $this->hLen);

        $seed = $maskedSeed ^ $seedMask;

        $dbMask = $this->_mgf1($seed, $this->k - $this->hLen - 1);

        $db = $maskedDB ^ $dbMask;

        $lHash2 = substr($db, 0, $this->hLen);

        $m = substr($db, $this->hLen);

        if ($lHash != $lHash2) {

            user_error('Decryption error', E_USER_NOTICE);

            return false;

        }

        $m = ltrim($m, chr(0));

        if (ord($m[0]) != 1) {

            user_error('Decryption error', E_USER_NOTICE);

            return false;

        }



        // Output the message M



        return substr($m, 1);

    }



    /**

     * RSAES-PKCS1-V1_5-ENCRYPT

     *

     * See {@link http://tools.ietf.org/html/rfc3447#section-7.2.1 RFC3447#section-7.2.1}.

     *

     * @access private

     * @param String $m

     * @return Stri…