diff options
Diffstat (limited to 'vendor/phpseclib/phpseclib2_compat')
27 files changed, 4215 insertions, 0 deletions
diff --git a/vendor/phpseclib/phpseclib2_compat/.github/workflows/ci.yml b/vendor/phpseclib/phpseclib2_compat/.github/workflows/ci.yml new file mode 100644 index 000000000..4d19f96c9 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/.github/workflows/ci.yml @@ -0,0 +1,61 @@ +name: CI +on: [push, pull_request] + +permissions: + contents: read # to fetch code (actions/checkout) + +jobs: + tests: + name: Tests + timeout-minutes: 10 + runs-on: ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v3 + - name: Setup PHP + uses: shivammathur/setup-php@v2 + with: + php-version: ${{ matrix.php-version }} + - name: Clone phpseclib v2 and update tests + run: | + git clone -b 2.0 --single-branch https://github.com/phpseclib/phpseclib.git temp + mv temp/tests tests + rm tests/Functional/Net/SCPSSH2UserStoryTest.php + rm tests/Unit/Net/SSH1Test.php + rm tests/Unit/Net/SSH2UnitTest.php + rm tests/Unit/Math/BigInteger/InternalTest.php + php .github/workflows/update.php + - name: Composer Install + run: composer install --no-interaction --no-cache + - name: Make Tests Compatiable With PHPUnit 9+ + if: matrix.php-version != '5.6' && matrix.php-version != '7.0' && matrix.php-version != '7.1' && matrix.php-version != '7.2' + run: php tests/make_compatible_with_phpunit9.php + - name: Setup Secure Shell Functional Tests + if: matrix.os == 'ubuntu-latest' + run: | + PHPSECLIB_SSH_USERNAME='phpseclib' + PHPSECLIB_SSH_PASSWORD='EePoov8po1aethu2kied1ne0' + + sudo useradd --create-home --base-dir /home "$PHPSECLIB_SSH_USERNAME" + echo "$PHPSECLIB_SSH_USERNAME:$PHPSECLIB_SSH_PASSWORD" | sudo chpasswd + ssh-keygen -t rsa -b 1024 -f "$HOME/.ssh/id_rsa" -q -N "" + eval `ssh-agent -s` + ssh-add "$HOME/.ssh/id_rsa" + sudo mkdir -p "/home/$PHPSECLIB_SSH_USERNAME/.ssh/" + sudo cp "$HOME/.ssh/id_rsa.pub" "/home/$PHPSECLIB_SSH_USERNAME/.ssh/authorized_keys" + sudo ssh-keyscan -t rsa localhost > "/tmp/known_hosts" + sudo cp "/tmp/known_hosts" "/home/$PHPSECLIB_SSH_USERNAME/.ssh/known_hosts" + sudo chown "$PHPSECLIB_SSH_USERNAME:$PHPSECLIB_SSH_USERNAME" "/home/$PHPSECLIB_SSH_USERNAME/.ssh/" -R + + echo "PHPSECLIB_SSH_HOSTNAME=localhost" >> $GITHUB_ENV + echo "PHPSECLIB_SSH_USERNAME=$PHPSECLIB_SSH_USERNAME" >> $GITHUB_ENV + echo "PHPSECLIB_SSH_PASSWORD=$PHPSECLIB_SSH_PASSWORD" >> $GITHUB_ENV + echo "PHPSECLIB_SSH_HOME=/home/phpseclib" >> $GITHUB_ENV + echo "SSH_AUTH_SOCK=$SSH_AUTH_SOCK" >> $GITHUB_ENV + - name: PHPUnit + run: vendor/bin/phpunit + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + php-version: ['5.6', '7.0', '7.1', '7.2', '7.3', '7.4', '8.0', '8.1', '8.2'] diff --git a/vendor/phpseclib/phpseclib2_compat/.github/workflows/update.php b/vendor/phpseclib/phpseclib2_compat/.github/workflows/update.php new file mode 100644 index 000000000..61cd00641 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/.github/workflows/update.php @@ -0,0 +1,12 @@ +<?php + +function replaceFileContents($fileName, $search, $replace) +{ + $fileContents = file_get_contents($fileName); + $updatedFileContents = preg_replace($search, $replace, $fileContents); + file_put_contents($fileName, $updatedFileContents); +} + +replaceFileContents('tests/PhpseclibTestCase.php', '~%s/../phpseclib/%s~', '%s/../src/%s'); +replaceFileContents('tests/Unit/Crypt/RSA/LoadKeyTest.php', '~ public function testSetPrivate\(\)~', ' private function skiptestSetPrivate()'); +replaceFileContents('tests/Unit/Crypt/RSA/ModeTest.php', '~ public function testOAEPWithLabel\(\)~', ' private function skiptestOAEPWithLabel()');
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/LICENSE b/vendor/phpseclib/phpseclib2_compat/LICENSE new file mode 100644 index 000000000..39a347e41 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 phpseclib + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/phpseclib/phpseclib2_compat/README.md b/vendor/phpseclib/phpseclib2_compat/README.md new file mode 100644 index 000000000..df4739d34 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/README.md @@ -0,0 +1,92 @@ +# phpseclib2_compat + +[](https://github.com/phpseclib/phpseclib2_compat/actions/workflows/ci.yml?query=branch%3A1.0) + +phpseclib 2.0 polyfill built with phpseclib 3.0 + +## Overview + +phpseclib 3.0 breaks backwards compatability with phpseclib 2.0. Most notably, public keys work completely differently. So let's say you wanted to use phpseclib 3.0 whilst some of your other dependencies still use phpseclib 2.0. What would you do in that instance? + +That's where phpseclib2_compat comes into play. Require phpseclib/phpseclib:~3.0 and phpseclib/phpseclib2_compat:~1.0 and your dependencies will magically start using phpseclib 3.0 even if they don't know it. + +Using phpseclib2_compat will actually bring a few enhancements to your dependencies. For example, while phpseclib 2.0 only supports RSA keys phpseclib2_compat sports support for ECDSA / DSA / Ed25519 / Ed449 keys. + +Consider this code sample: + +```php +use phpseclib\Crypt\RSA; + +$rsa = new RSA; +$rsa->loadKey('ecdsa private key'); + +$ssh = new SSH2('website.com'); +$ssh->login('username', $rsa); +``` +That'll work with phpseclib2_compat, even with an ECDSA private key, whereas in phpseclib 2.0 it would not work. + +SSH1 and SCP are not supported but those were likely never frequently used anyway. + +## Using the old cipher suite + +phpseclib 3.0 uses a different cipher suite (an expanded one) than 2.0. If this causes you issues you can use the 2.0 ciphersuite by doing this prior to calling `$ssh->login()`: + +```php +$methods = [ + 'crypt' => array_intersect([ + 'arcfour256', + 'arcfour128', + 'aes128-ctr', + 'aes192-ctr', + 'aes256-ctr', + 'twofish128-ctr', + 'twofish192-ctr', + 'twofish256-ctr', + 'aes128-cbc', + 'aes192-cbc', + 'aes256-cbc', + 'twofish128-cbc', + 'twofish192-cbc', + 'twofish256-cbc', + 'twofish-cbc', + 'blowfish-ctr', + 'blowfish-cbc', + '3des-ctr', + '3des-cbc' + ], $ssh->getSupportedEncryptionAlgorithms()), + 'mac' => [ + 'hmac-sha2-256', + 'hmac-sha1-96', + 'hmac-sha1', + 'hmac-md5-96', + 'hmac-md5' + ], + 'comp' => ['none'] +]; + +$ssh->setPreferredAlgorithms([ + 'kex' => [ + 'curve25519-sha256@libssh.org', + 'diffie-hellman-group-exchange-sha256', + 'diffie-hellman-group-exchange-sha1', + 'diffie-hellman-group14-sha1', + 'diffie-hellman-group14-sha256' + ], + 'hostkey' => [ + 'rsa-sha2-256', + 'rsa-sha2-512', + 'ssh-rsa', + 'ssh-dss' + ], + 'client_to_server' => $methods, + 'server_to_client' => $methods +]); +``` + +## Installation + +With [Composer](https://getcomposer.org/): + +``` +composer require phpseclib/phpseclib2_compat:~1.0 +``` diff --git a/vendor/phpseclib/phpseclib2_compat/composer.json b/vendor/phpseclib/phpseclib2_compat/composer.json new file mode 100644 index 000000000..f32ef85e8 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/composer.json @@ -0,0 +1,30 @@ +{ + "name": "phpseclib/phpseclib2_compat", + "description": "phpseclib 2.0 polyfill built with phpseclib 3.0", + "type": "library", + "homepage": "https://github.com/phpseclib/phpseclib2_compat", + "license": "MIT", + "authors": [ + { + "name": "Jim Wigginton", + "email": "terrafrost@php.net", + "role": "Lead Developer" + } + ], + "support": { + "issues": "https://github.com/phpseclib/phpseclib2_compat/issues", + "source": "https://github.com/phpseclib/phpseclib2_compat" + }, + "provide": { + "phpseclib/phpseclib": "2.0.47" + }, + "require": { + "phpseclib/phpseclib": "^3.0" + }, + "require-dev": { + "phpunit/phpunit": "^5.7|^6.0|^9.4" + }, + "autoload": { + "psr-4": {"phpseclib\\": "src/"} + } +} diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/AES.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/AES.php new file mode 100644 index 000000000..0e4da3543 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/AES.php @@ -0,0 +1,93 @@ +<?php + +/** + * Pure-PHP implementation of AES. + * + * Uses mcrypt, if available/possible, and an internal implementation, otherwise. + * + * PHP version 5 + * + * NOTE: Since AES.php is (for compatibility and phpseclib-historical reasons) virtually + * just a wrapper to Rijndael.php you may consider using Rijndael.php instead of + * to save one include_once(). + * + * If {@link self::setKeyLength() setKeyLength()} isn't called, it'll be calculated from + * {@link self::setKey() setKey()}. ie. if the key is 128-bits, the key length will be 128-bits. If it's 136-bits + * it'll be null-padded to 192-bits and 192 bits will be the key length until {@link self::setKey() setKey()} + * is called, again, at which point, it'll be recalculated. + * + * Since \phpseclib\Crypt\AES extends \phpseclib\Crypt\Rijndael, some functions are available to be called that, in the context of AES, don't + * make a whole lot of sense. {@link self::setBlockLength() setBlockLength()}, for instance. Calling that function, + * however possible, won't do anything (AES has a fixed block length whereas Rijndael has a variable one). + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $aes = new \phpseclib\Crypt\AES(); + * + * $aes->setKey('abcdefghijklmnop'); + * + * $size = 10 * 1024; + * $plaintext = ''; + * for ($i = 0; $i < $size; $i++) { + * $plaintext.= 'a'; + * } + * + * echo $aes->decrypt($aes->encrypt($plaintext)); + * ?> + * </code> + * + * @category Crypt + * @package AES + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2008 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementation of AES. + * + * @package AES + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class AES extends Rijndael +{ + /** + * Dummy function + * + * Since \phpseclib\Crypt\AES extends \phpseclib\Crypt\Rijndael, this function is, technically, available, but it doesn't do anything. + * + * @see \phpseclib\Crypt\Rijndael::setBlockLength() + * @access public + * @param int $length + */ + function setBlockLength($length) + { + return; + } + + /** + * Turns key lengths, be they valid or invalid, to valid key lengths + * + * @param int $length + * @access private + * @return int + */ + protected function calculateNewKeyLength($length) + { + switch (true) { + case $length <= 128: + return 128; + case $length <= 192: + return 192; + default: + return 256; + } + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/Base.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Base.php new file mode 100644 index 000000000..fad69c023 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Base.php @@ -0,0 +1,585 @@ +<?php + +/** + * Base Class for all \phpseclib\Crypt\* cipher classes + * + * PHP version 5 + * + * @category Crypt + * @package Base + * @author Jim Wigginton <terrafrost@php.net> + * @author Hans-Juergen Petrich <petrich@tronic-media.com> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +use phpseclib3\Exception\BadDecryptionException; +use phpseclib3\Exception\InconsistentSetupException; + +/** + * Base Class for all \phpseclib\Crypt\* cipher classes + * + * @package Base + * @author Jim Wigginton <terrafrost@php.net> + * @author Hans-Juergen Petrich <petrich@tronic-media.com> + */ +abstract class Base +{ + /**#@+ + * @access public + * @see \phpseclib\Crypt\Base::encrypt() + * @see \phpseclib\Crypt\Base::decrypt() + */ + /** + * Encrypt / decrypt using the Counter mode. + * + * Set to -1 since that's what Crypt/Random.php uses to index the CTR mode. + * + * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Counter_.28CTR.29 + */ + const MODE_CTR = -1; + /** + * Encrypt / decrypt using the Electronic Code Book mode. + * + * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Electronic_codebook_.28ECB.29 + */ + const MODE_ECB = 1; + /** + * Encrypt / decrypt using the Code Book Chaining mode. + * + * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher-block_chaining_.28CBC.29 + */ + const MODE_CBC = 2; + /** + * Encrypt / decrypt using the Cipher Feedback mode. + * + * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher_feedback_.28CFB.29 + */ + const MODE_CFB = 3; + /** + * Encrypt / decrypt using the Cipher Feedback mode (8bit) + */ + const MODE_CFB8 = 38; + /** + * Encrypt / decrypt using the Output Feedback mode (8bit) + */ + const MODE_OFB8 = 7; + /** + * Encrypt / decrypt using the Output Feedback mode. + * + * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Output_feedback_.28OFB.29 + */ + const MODE_OFB = 4; + /** + * Encrypt / decrypt using streaming mode. + */ + const MODE_STREAM = 5; + /** + * Encrypt / decrypt using Galois/Counter mode. + * + * @link https://en.wikipedia.org/wiki/Galois/Counter_Mode + */ + const MODE_GCM = 6; + /**#@-*/ + + /**#@+ + * @access private + * @see \phpseclib3\Crypt\Common\SymmetricKey::__construct() + */ + /** + * Base value for the internal implementation $engine switch + */ + const ENGINE_INTERNAL = 1; + /** + * Base value for the eval() implementation $engine switch + */ + const ENGINE_EVAL = 4; + /** + * Base value for the mcrypt implementation $engine switch + */ + const ENGINE_MCRYPT = 2; + /** + * Base value for the openssl implementation $engine switch + */ + const ENGINE_OPENSSL = 3; + /** + * Base value for the libsodium implementation $engine switch + */ + const ENGINE_LIBSODIUM = 5; + /** + * Base value for the openssl / gcm implementation $engine switch + */ + const ENGINE_OPENSSL_GCM = 6; + /**#@-*/ + + /** + * Engine Map + * + * @access private + * @see \phpseclib3\Crypt\Common\SymmetricKey::getEngine() + */ + const ENGINE_MAP = [ + self::ENGINE_INTERNAL => 'PHP', + self::ENGINE_EVAL => 'Eval', + self::ENGINE_MCRYPT => 'mcrypt', + self::ENGINE_OPENSSL => 'OpenSSL', + self::ENGINE_LIBSODIUM => 'libsodium', + self::ENGINE_OPENSSL_GCM => 'OpenSSL (GCM)' + ]; + + /** + * The Cipher + * + * @var \phpseclib3\Crypt\Common\SymmetricKey + * @access private + */ + protected $cipher; + + /** + * The Key + * + * @see self::setKey() + * @var string + * @access private + */ + protected $key = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; + + /** + * Password Parameters + * + * @see self::setPassword() + * @var array + * @access private + */ + protected $password = []; + + /** + * The Key Length (in bytes) + * + * @see self::setKeyLength() + * @var int + * @access private + */ + protected $key_length = 128; + + /** + * Does internal cipher state need to be (re)initialized? + * + * @see self::setKey() + * @var bool + * @access private + */ + private $changed = true; + + /** + * Has the IV been set? + * + * @var bool + * @access private + */ + protected $ivSet = false; + + /** + * Has the key length been explictly set? + * + * @var bool + * @access private + */ + protected $explicit_key_length = false; + + /** + * Default Constructor. + * + * Determines whether or not the mcrypt extension should be used. + * + * $mode could be: + * + * - self::MODE_ECB + * + * - self::MODE_CBC + * + * - self::MODE_CTR + * + * - self::MODE_CFB + * + * - self::MODE_OFB + * + * If not explicitly set, self::MODE_CBC will be used. + * + * @param int $mode + * @access public + */ + public function __construct($mode = self::MODE_CBC) + { + $map = [ + self::MODE_CTR => 'ctr', + self::MODE_ECB => 'ecb', + self::MODE_CBC => 'cbc', + self::MODE_CFB => 'cfb', + self::MODE_CFB8 => 'cfb8', + self::MODE_OFB => 'ofb', + self::MODE_OFB8 => 'ofb8', + self::MODE_GCM => 'gcm', + self::MODE_STREAM => 'stream' + ]; + if (!isset($map[$mode])) { + $mode = self::MODE_CBC; + } + $class = new \ReflectionClass(static::class); + $class = "phpseclib3\\Crypt\\" . $class->getShortName(); + $this->cipher = new $class($map[$mode]); + $this->key_length = $this->cipher->getKeyLength(); + } + + /** + * Sets the initialization vector. (optional) + * + * SetIV is not required when self::MODE_ECB (or ie for AES: \phpseclib\Crypt\AES::MODE_ECB) is being used. If not explicitly set, it'll be assumed + * to be all zero's. + * + * @access public + * @param string $iv + * @internal Can be overwritten by a sub class, but does not have to be + */ + public function setIV($iv) + { + $this->ivSet = true; + + if (!$this->cipher->usesIV()) { + return; + } + + $length = $this->cipher->getBlockLengthInBytes(); + $iv = str_pad(substr($iv, 0, $length), $length, "\0"); + + try { + $this->cipher->setIV($iv); + } catch (\Exception $e) {} + } + + /** + * Sets the key length. + * + * Keys with explicitly set lengths need to be treated accordingly + * + * @access public + * @param int $length + */ + public function setKeyLength($length) + { + // algorithms that have a fixed key length should override this with a method that does nothing + $this->changed = true; + $this->key_length = static::calculateNewKeyLength($length); + $this->explicit_key_length = true; + } + + /** + * Returns the current key length in bits + * + * @access public + * @return int + */ + public function getKeyLength() + { + return $this->key_length; + } + + /** + * Returns the current block length in bits + * + * @access public + * @return int + */ + public function getBlockLength() + { + return $this->cipher->getBlockLength(); + } + + /** + * Sets the key. + * + * The min/max length(s) of the key depends on the cipher which is used. + * If the key not fits the length(s) of the cipher it will paded with null bytes + * up to the closest valid key length. If the key is more than max length, + * we trim the excess bits. + * + * If the key is not explicitly set, it'll be assumed to be all null bytes. + * + * @access public + * @param string $key + * @internal Could, but not must, extend by the child Crypt_* class + */ + public function setKey($key) + { + $this->key = $key; + $this->password = []; + if (!$this->explicit_key_length) { + $this->key_length = static::calculateNewKeyLength(strlen($key) << 3); + } + $this->changed = true; + } + + /** + * Sets the password. + * + * Depending on what $method is set to, setPassword()'s (optional) parameters are as follows: + * {@link http://en.wikipedia.org/wiki/PBKDF2 pbkdf2} or pbkdf1: + * $hash, $salt, $count, $dkLen + * + * Where $hash (default = sha1) currently supports the following hashes: see: Crypt/Hash.php + * + * @see Crypt/Hash.php + * @param string $password + * @param string $method + * @return bool + * @access public + * @internal Could, but not must, extend by the child Crypt_* class + */ + public function setPassword($password, $method = 'pbkdf2') + { + $this->password = func_get_args(); + $this->cipher->setKeyLength($this->key_length); + $this->cipher->setPassword(...func_get_args()); + } + + /** + * Encrypts a message. + * + * $plaintext will be padded with additional bytes such that it's length is a multiple of the block size. Other cipher + * implementations may or may not pad in the same manner. Other common approaches to padding and the reasons why it's + * necessary are discussed in the following + * URL: + * + * {@link http://www.di-mgt.com.au/cryptopad.html http://www.di-mgt.com.au/cryptopad.html} + * + * An alternative to padding is to, separately, send the length of the file. This is what SSH, in fact, does. + * strlen($plaintext) will still need to be a multiple of the block size, however, arbitrary values can be added to make it that + * length. + * + * @see self::decrypt() + * @access public + * @param string $plaintext + * @return string $ciphertext + * @internal Could, but not must, extend by the child Crypt_* class + */ + public function encrypt($plaintext) + { + if ($this->changed) { + $this->setup(); + } + + try { + return $this->cipher->encrypt($plaintext); + } catch (\LengthException $e) { + user_error($e->getMessage()); + $this->cipher->enablePadding(); + return $this->cipher->encrypt($plaintext); + } + } + + /** + * Decrypts a message. + * + * If strlen($ciphertext) is not a multiple of the block size, null bytes will be added to the end of the string until + * it is. + * + * @see self::encrypt() + * @access public + * @param string $ciphertext + * @return string $plaintext + * @internal Could, but not must, extend by the child Crypt_* class + */ + public function decrypt($ciphertext) + { + if ($this->changed) { + $this->setup(); + } + + try { + return $this->cipher->decrypt($ciphertext); + } catch (\LengthException $e) { + $len = strlen($ciphertext); + $block_size = $this->cipher->getBlockLengthInBytes(); + $ciphertext = str_pad($ciphertext, $len + ($block_size - $len % $block_size) % $block_size, chr(0)); + try { + return $this->cipher->decrypt($ciphertext); + } catch (BadDecryptionException $e) { + return false; + } + } catch (\Exception $e) { + return false; + } + } + + /** + * Setup IV and key + */ + protected function setup() + { + // we set this just in case it was already set to anything via setPassword() + $temp = $this->explicit_key_length; + $this->setKeyLength($this->key_length); + $this->explicit_key_length = $temp; + if ($this->explicit_key_length) { + $this->cipher->setKeyLength($this->key_length); + } + if (empty($this->password)) { + $key_length = $this->key_length >> 3; + $key = str_pad(substr($this->key, 0, $key_length), $key_length, "\0"); + $this->cipher->setKey($key); + } else { + $this->cipher->setPassword(...$this->password); + } + if (!$this->ivSet) { + $this->setIV(''); + } + $this->changed = false; + } + + /** + * Pad "packets". + * + * Block ciphers working by encrypting between their specified [$this->]block_size at a time + * If you ever need to encrypt or decrypt something that isn't of the proper length, it becomes necessary to + * pad the input so that it is of the proper length. + * + * Padding is enabled by default. Sometimes, however, it is undesirable to pad strings. Such is the case in SSH, + * where "packets" are padded with random bytes before being encrypted. Unpad these packets and you risk stripping + * away characters that shouldn't be stripped away. (SSH knows how many bytes are added because the length is + * transmitted separately) + * + * @see self::disablePadding() + * @access public + */ + public function enablePadding() + { + $this->cipher->enablePadding(); + } + + /** + * Do not pad packets. + * + * @see self::enablePadding() + * @access public + */ + public function disablePadding() + { + $this->cipher->disablePadding(); + } + + /** + * Treat consecutive "packets" as if they are a continuous buffer. + * + * Say you have a 32-byte plaintext $plaintext. Using the default behavior, the two following code snippets + * will yield different outputs: + * + * <code> + * echo $rijndael->encrypt(substr($plaintext, 0, 16)); + * echo $rijndael->encrypt(substr($plaintext, 16, 16)); + * </code> + * <code> + * echo $rijndael->encrypt($plaintext); + * </code> + * + * The solution is to enable the continuous buffer. Although this will resolve the above discrepancy, it creates + * another, as demonstrated with the following: + * + * <code> + * $rijndael->encrypt(substr($plaintext, 0, 16)); + * echo $rijndael->decrypt($rijndael->encrypt(substr($plaintext, 16, 16))); + * </code> + * <code> + * echo $rijndael->decrypt($rijndael->encrypt(substr($plaintext, 16, 16))); + * </code> + * + * With the continuous buffer disabled, these would yield the same output. With it enabled, they yield different + * outputs. The reason is due to the fact that the initialization vector's change after every encryption / + * decryption round when the continuous buffer is enabled. When it's disabled, they remain constant. + * + * Put another way, when the continuous buffer is enabled, the state of the \phpseclib\Crypt\*() object changes after each + * encryption / decryption round, whereas otherwise, it'd remain constant. For this reason, it's recommended that + * continuous buffers not be used. They do offer better security and are, in fact, sometimes required (SSH uses them), + * however, they are also less intuitive and more likely to cause you problems. + * + * @see self::disableContinuousBuffer() + * @access public + * @internal Could, but not must, extend by the child Crypt_* class + */ + public function enableContinuousBuffer() + { + try { + $this->cipher->enableContinuousBuffer(); + } catch (\BadMethodCallException $e) { + user_error($e->getMessage()); + } + } + + /** + * Treat consecutive packets as if they are a discontinuous buffer. + * + * The default behavior. + * + * @see self::enableContinuousBuffer() + * @access public + * @internal Could, but not must, extend by the child Crypt_* class + */ + public function disableContinuousBuffer() + { + $this->cipher->disableContinuousBuffer(); + } + + /** + * Test for engine validity + * + * @see self::__construct() + * @param int $engine + * @access public + * @return bool + */ + public function isValidEngine($engine) + { + $map = self::ENGINE_MAP; + return $this->cipher->isValidEngine($map[$engine]); + } + + /** + * Sets the preferred crypt engine + * + * Currently, $engine could be: + * + * - \phpseclib\Crypt\Base::ENGINE_OPENSSL [very fast] + * + * - \phpseclib\Crypt\Base::ENGINE_MCRYPT [fast] + * + * - \phpseclib\Crypt\Base::ENGINE_INTERNAL [slow] + * + * If the preferred crypt engine is not available the fastest available one will be used + * + * @see self::__construct() + * @param int $engine + * @access public + */ + public function setPreferredEngine($engine) + { + $map = self::ENGINE_MAP; + $this->cipher->setPreferredEngine($map[$engine]); + } + + /** + * Returns the engine currently being utilized + * + * @see self::_setEngine() + * @access public + */ + public function getEngine() + { + static $reverseMap; + if (!isset($reverseMap)) { + $reverseMap = array_flip(self::ENGINE_MAP); + } + return $reverseMap[$this->cipher->getEngine()]; + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/Blowfish.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Blowfish.php new file mode 100644 index 000000000..f2cb68ee8 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Blowfish.php @@ -0,0 +1,66 @@ +<?php + +/** + * Pure-PHP implementation of Blowfish. + * + * Uses mcrypt, if available, and an internal implementation, otherwise. + * + * PHP version 5 + * + * Useful resources are as follows: + * + * - {@link http://en.wikipedia.org/wiki/Blowfish_(cipher) Wikipedia description of Blowfish} + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $blowfish = new \phpseclib\Crypt\Blowfish(); + * + * $blowfish->setKey('12345678901234567890123456789012'); + * + * $plaintext = str_repeat('a', 1024); + * + * echo $blowfish->decrypt($blowfish->encrypt($plaintext)); + * ?> + * </code> + * + * @category Crypt + * @package Blowfish + * @author Jim Wigginton <terrafrost@php.net> + * @author Hans-Juergen Petrich <petrich@tronic-media.com> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementation of Blowfish. + * + * @package Blowfish + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class Blowfish extends Base +{ + /** + * Turns key lengths, be they valid or invalid, to valid key lengths + * + * @param int $length + * @access private + * @return int + */ + protected function calculateNewKeyLength($length) + { + switch (true) { + case $length < 32: + return 32; + case $length > 448: + return 448; + } + return $length; + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/DES.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/DES.php new file mode 100644 index 000000000..512c59a27 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/DES.php @@ -0,0 +1,65 @@ +<?php + +/** + * Pure-PHP implementation of DES. + * + * Uses mcrypt, if available, and an internal implementation, otherwise. + * + * PHP version 5 + * + * Useful resources are as follows: + * + * - {@link http://en.wikipedia.org/wiki/DES_supplementary_material Wikipedia: DES supplementary material} + * - {@link http://www.itl.nist.gov/fipspubs/fip46-2.htm FIPS 46-2 - (DES), Data Encryption Standard} + * - {@link http://www.cs.eku.edu/faculty/styer/460/Encrypt/JS-DES.html JavaScript DES Example} + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $des = new \phpseclib\Crypt\DES(); + * + * $des->setKey('abcdefgh'); + * + * $size = 10 * 1024; + * $plaintext = ''; + * for ($i = 0; $i < $size; $i++) { + * $plaintext.= 'a'; + * } + * + * echo $des->decrypt($des->encrypt($plaintext)); + * ?> + * </code> + * + * @category Crypt + * @package DES + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementation of DES. + * + * @package DES + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class DES extends Base +{ + /** + * Turns key lengths, be they valid or invalid, to valid key lengths + * + * @param int $length + * @access private + * @return int + */ + protected function calculateNewKeyLength($length) + { + return 64; + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/Hash.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Hash.php new file mode 100644 index 000000000..de7942705 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Hash.php @@ -0,0 +1,145 @@ +<?php + +/** + * Pure-PHP implementations of keyed-hash message authentication codes (HMACs) and various cryptographic hashing functions. + * + * Uses hash() or mhash() if available and an internal implementation, otherwise. Currently supports the following: + * + * md2, md5, md5-96, sha1, sha1-96, sha256, sha256-96, sha384, and sha512, sha512-96 + * + * If {@link self::setKey() setKey()} is called, {@link self::hash() hash()} will return the HMAC as opposed to + * the hash. If no valid algorithm is provided, sha1 will be used. + * + * PHP version 5 + * + * {@internal The variable names are the same as those in + * {@link http://tools.ietf.org/html/rfc2104#section-2 RFC2104}.}} + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $hash = new \phpseclib\Crypt\Hash('sha1'); + * + * $hash->setKey('abcdefg'); + * + * echo base64_encode($hash->hash('abcdefg')); + * ?> + * </code> + * + * @category Crypt + * @package Hash + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementations of keyed-hash message authentication codes (HMACs) and various cryptographic hashing functions. + * + * @package Hash + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class Hash +{ + /**#@+ + * @access private + * @see \phpseclib\Crypt\Hash::__construct() + */ + /** + * Toggles the internal implementation + */ + const MODE_INTERNAL = 1; + /**#@-*/ + + /** + * Hash Object + * + * @see self::setHash() + * @var null|\phpseclib3\Crypt\Hash + * @access private + */ + private $hash; + + /** + * Default Constructor. + * + * @param string $hash + * @return \phpseclib\Crypt\Hash + * @access public + */ + public function __construct($hash = 'sha1') + { + $this->setHash($hash); + } + + /** + * Sets the key for HMACs + * + * Keys can be of any length. + * + * @access public + * @param string $key + */ + public function setKey($key = false) + { + $this->hash->setKey($key); + } + + /** + * Gets the hash function. + * + * As set by the constructor or by the setHash() method. + * + * @access public + * @return string + */ + public function getHash() + { + return $this->hash->getHash(); + } + + /** + * Sets the hash function. + * + * @access public + * @param string $hash + */ + public function setHash($hash) + { + $this->hash = new \phpseclib3\Crypt\Hash; + try { + $this->hash->setHash($hash); + } catch (\phpseclib3\Exception\UnsupportedAlgorithmException $e) { + $this->hash->setHash('sha1'); + } + } + + /** + * Compute the HMAC. + * + * @access public + * @param string $text + * @return string + */ + public function hash($text) + { + return $this->hash->hash($text); + } + + /** + * Returns the hash length (in bytes) + * + * @access public + * @return int + */ + public function getLength() + { + return $this->hash->getLengthInBytes(); + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/RC2.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/RC2.php new file mode 100644 index 000000000..b23f73bca --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/RC2.php @@ -0,0 +1,132 @@ +<?php + +/** + * Pure-PHP implementation of RC2. + * + * Uses mcrypt, if available, and an internal implementation, otherwise. + * + * PHP version 5 + * + * Useful resources are as follows: + * + * - {@link http://tools.ietf.org/html/rfc2268} + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $rc2 = new \phpseclib\Crypt\RC2(); + * + * $rc2->setKey('abcdefgh'); + * + * $plaintext = str_repeat('a', 1024); + * + * echo $rc2->decrypt($rc2->encrypt($plaintext)); + * ?> + * </code> + * + * @category Crypt + * @package RC2 + * @author Patrick Monnerat <pm@datasphere.ch> + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementation of RC2. + * + * @package RC2 + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class RC2 extends Base +{ + /** + * Default Constructor. + * + * Determines whether or not the mcrypt extension should be used. + * + * $mode could be: + * + * - self::MODE_ECB + * + * - self::MODE_CBC + * + * - self::MODE_CTR + * + * - self::MODE_CFB + * + * - self::MODE_OFB + * + * If not explicitly set, self::MODE_CBC will be used. + * + * @param int $mode + * @access public + */ + public function __construct($mode = self::MODE_CBC) + { + parent::__construct($mode); + $this->key_length = 8; + } + + /** + * Turns key lengths, be they valid or invalid, to valid key lengths + * + * @param int $length + * @access private + * @return int + */ + protected function calculateNewKeyLength($length) + { + switch (true) { + case $length < 8: + return 8; + case $length > 1024: + return 1024; + } + + return $length; + } + + /** + * Setup IV and key + */ + protected function setup() + { + if ($this->explicit_key_length) { + $this->cipher->setKeyLength($this->key_length); + } + $this->cipher->setKey($this->key); + if (!$this->ivSet) { + $this->setIV(''); + } + $this->changed = false; + } + + /** + * Sets the key. + * + * Keys can be of any length. RC2, itself, uses 8 to 1024 bit keys (eg. + * strlen($key) <= 128), however, we only use the first 128 bytes if $key + * has more then 128 bytes in it, and set $key to a single null byte if + * it is empty. + * + * If the key is not explicitly set, it'll be assumed to be a single + * null byte. + * + * @see \phpseclib\Crypt\Base::setKey() + * @access public + * @param string $key + * @param int $t1 optional Effective key length in bits. + */ + function setKey($key, $t1 = 0) + { + parent::setKey($key); + if ($t1) { + $this->setKeyLength($t1); + } + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/RC4.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/RC4.php new file mode 100644 index 000000000..78781f553 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/RC4.php @@ -0,0 +1,74 @@ +<?php + +/** + * Pure-PHP implementation of RC4. + * + * Uses mcrypt, if available, and an internal implementation, otherwise. + * + * PHP version 5 + * + * Useful resources are as follows: + * + * - {@link http://www.mozilla.org/projects/security/pki/nss/draft-kaukonen-cipher-arcfour-03.txt ARCFOUR Algorithm} + * - {@link http://en.wikipedia.org/wiki/RC4 - Wikipedia: RC4} + * + * RC4 is also known as ARCFOUR or ARC4. The reason is elaborated upon at Wikipedia. This class is named RC4 and not + * ARCFOUR or ARC4 because RC4 is how it is referred to in the SSH1 specification. + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $rc4 = new \phpseclib\Crypt\RC4(); + * + * $rc4->setKey('abcdefgh'); + * + * $size = 10 * 1024; + * $plaintext = ''; + * for ($i = 0; $i < $size; $i++) { + * $plaintext.= 'a'; + * } + * + * echo $rc4->decrypt($rc4->encrypt($plaintext)); + * ?> + * </code> + * + * @category Crypt + * @package RC4 + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementation of RC4. + * + * @package RC4 + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class RC4 extends Base +{ + /** + * Turns key lengths, be they valid or invalid, to valid key lengths + * + * @param int $length + * @access private + * @return int + */ + protected function calculateNewKeyLength($length) + { + switch (true) { + case $length < 8: + return 8; + case $length > 2048: + return 2048; + } + + return $length; + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/RSA.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/RSA.php new file mode 100644 index 000000000..7a45a0bb5 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/RSA.php @@ -0,0 +1,948 @@ +<?php + +/** + * Pure-PHP PKCS#1 (v2.1) compliant implementation of RSA. + * + * PHP version 5 + * + * Here's an example of how to encrypt and decrypt text with this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $rsa = new \phpseclib\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 'vendor/autoload.php'; + * + * $rsa = new \phpseclib\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> + * + * @category Crypt + * @package RSA + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2009 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +use phpseclib3\Crypt\RSA as RSA2; +use phpseclib3\Crypt\PublicKeyLoader; +use phpseclib3\Crypt\Common\AsymmetricKey; +use phpseclib3\Crypt\Common\PublicKey; +use phpseclib3\Crypt\Common\PrivateKey; +use phpseclib3\Exception\UnsupportedAlgorithmException; +use phpseclib3\Exception\UnsupportedFormatException; +use phpseclib3\Exception\NoKeyLoadedException; +use phpseclib3\Crypt\Common\Formats\Keys\PuTTY; +use phpseclib3\Crypt\Common\Formats\Keys\OpenSSH; +use phpseclib3\Math\BigInteger; +use phpseclib\Math\BigInteger as BigInteger2; + +/** + * Pure-PHP PKCS#1 compliant implementation of RSA. + * + * @package RSA + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class RSA +{ + /**#@+ + * @access public + * @see self::encrypt() + * @see self::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 self::setHash() + * @see self::setMGFHash() + */ + const ENCRYPTION_OAEP = 1; + /** + * Use PKCS#1 padding. + * + * Although self::ENCRYPTION_OAEP offers more security, including PKCS#1 padding is necessary for purposes of backwards + * compatibility with protocols (like SSH-1) written before OAEP's introduction. + */ + const ENCRYPTION_PKCS1 = 2; + /** + * Do not use any padding + * + * Although this method is not recommended it can none-the-less sometimes be useful if you're trying to decrypt some legacy + * stuff, if you're trying to diagnose why an encrypted message isn't decrypting, etc. + */ + const ENCRYPTION_NONE = 3; + /**#@-*/ + + /**#@+ + * @access public + * @see self::sign() + * @see self::verify() + * @see self::setHash() + */ + /** + * Use the Probabilistic Signature Scheme for signing + * + * Uses sha1 by default. + * + * @see self::setSaltLength() + * @see self::setMGFHash() + */ + const SIGNATURE_PSS = 1; + /** + * Use the PKCS#1 scheme by default. + * + * Although self::SIGNATURE_PSS offers more security, including PKCS#1 signing is necessary for purposes of backwards + * compatibility with protocols (like SSH-2) written before PSS's introduction. + */ + const SIGNATURE_PKCS1 = 2; + /**#@-*/ + + /**#@+ + * @access public + * @see \phpseclib\Crypt\RSA::createKey() + * @see \phpseclib\Crypt\RSA::setPrivateKeyFormat() + */ + /** + * PKCS#1 formatted private key + * + * Used by OpenSSH + */ + const PRIVATE_FORMAT_PKCS1 = 0; + /** + * PuTTY formatted private key + */ + const PRIVATE_FORMAT_PUTTY = 1; + /** + * XML formatted private key + */ + const PRIVATE_FORMAT_XML = 2; + /** + * PKCS#8 formatted private key + */ + const PRIVATE_FORMAT_PKCS8 = 8; + /** + * OpenSSH formatted private key + */ + const PRIVATE_FORMAT_OPENSSH = 9; + /**#@-*/ + + /**#@+ + * @access public + * @see \phpseclib\Crypt\RSA::createKey() + * @see \phpseclib\Crypt\RSA::setPublicKeyFormat() + */ + /** + * Raw public key + * + * An array containing two \phpseclib\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 + */ + const PUBLIC_FORMAT_RAW = 3; + /** + * PKCS#1 formatted public key (raw) + * + * Used by File/X509.php + * + * Has the following header: + * + * -----BEGIN RSA PUBLIC KEY----- + * + * Analogous to ssh-keygen's pem format (as specified by -m) + */ + const PUBLIC_FORMAT_PKCS1 = 4; + const PUBLIC_FORMAT_PKCS1_RAW = 4; + /** + * XML formatted public key + */ + const PUBLIC_FORMAT_XML = 5; + /** + * OpenSSH formatted public key + * + * Place in $HOME/.ssh/authorized_keys + */ + const PUBLIC_FORMAT_OPENSSH = 6; + /** + * PKCS#1 formatted public key (encapsulated) + * + * Used by PHP's openssl_public_encrypt() and openssl's rsautl (when -pubin is set) + * + * Has the following header: + * + * -----BEGIN PUBLIC KEY----- + * + * Analogous to ssh-keygen's pkcs8 format (as specified by -m). Although PKCS8 + * is specific to private keys it's basically creating a DER-encoded wrapper + * for keys. This just extends that same concept to public keys (much like ssh-keygen) + */ + const PUBLIC_FORMAT_PKCS8 = 7; + /**#@-*/ + + /** + * The Original Key + * + * @see self::getComment() + * @var string + * @access private + */ + private $origKey = null; + + /** + * The Key + * + * @var \phpseclib3\Crypt\Common\AsymmetricKey + * @access private + */ + private $key = null; + + /** + * Password + * + * @var string + * @access private + */ + private $password = false; + + /** + * Private Key Format + * + * @var int + * @access private + */ + private $privateKeyFormat = self::PRIVATE_FORMAT_PKCS1; + + /** + * Public Key Format + * + * @var int + * @access public + */ + private $publicKeyFormat = self::PUBLIC_FORMAT_PKCS1; + + /** + * Public key comment field. + * + * @var string + * @access private + */ + private $comment = 'phpseclib-generated-key'; + + /** + * Encryption mode + * + * @var int + * @access private + */ + private $encryptionMode = self::ENCRYPTION_OAEP; + + /** + * Signature mode + * + * @var int + * @access private + */ + private $signatureMode = self::SIGNATURE_PSS; + + /** + * Hash name + * + * @var string + * @access private + */ + private $hash = 'sha1'; + + /** + * Hash function for the Mask Generation Function + * + * @var string + * @access private + */ + private $mgfHash = 'sha1'; + + /** + * Length of salt + * + * @var int + * @access private + */ + private $sLen; + + /** + * The constructor + * + * @return \phpseclib\Crypt\RSA + * @access public + */ + public function __construct() + { + // don't do anything + } + + /** + * 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 \phpseclib\Crypt\RSA::createKey() as the third parameter for further processing. + * + * @access public + * @param int $bits + */ + public function createKey($bits = 1024) + { + $privatekey = RSA2::createKey($bits); + + return [ + 'privatekey' => $privatekey, + 'publickey' => $privatekey->getPublicKey(), + 'partialkey' => false + ]; + } + + /** + * Returns the key size + * + * More specifically, this returns the size of the modulo in bits. + * + * @access public + * @return int + */ + public function getSize() + { + // for EC and RSA keys this'll return an integer + // for DSA keys this'll return an array (L + N) + return isset($this->key) ? $this->key->getLength() : 0; + } + + /** + * 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_string($password) is true. + * + * @see self::createKey() + * @see self::loadKey() + * @access public + * @param string $password + */ + public function setPassword($password = false) + { + $this->password = $password; + } + + /** + * Loads a public or private key + * + * Returns true on success and false on failure (ie. an incorrect password was provided or the key was malformed) + * + * @access public + * @param string|RSA|array $key + * @param bool|int $type optional + * @return bool + */ + public function loadKey($key) + { + if ($key instanceof AsymmetricKey) { + $this->key = $key; + } else if ($key instanceof RSA) { + $this->key = $key->key; + } else { + try { + if (is_array($key)) { + foreach ($key as &$value) { + if ($value instanceof BigInteger2) { + $value = new BigInteger($value->toBytes(true), -256); + } + } + } + $this->key = PublicKeyLoader::load($key, $this->password); + } catch (NoKeyLoadedException $e) { + $this->key = $this->origKey = null; + return false; + } + $this->origKey = $key; + } + + // with phpseclib 2.0 loading a key does not reset any of the following + // so we'll need to preserve the old settings whenever a new key is loaded + // with this shim + $this->setEncryptionMode($this->encryptionMode); + //$this->setSignatureMode($this->signatureMode); + $this->setHash($this->hash); + $this->setMGFHash($this->mgfHash); + $this->setSaltLength($this->sLen); + + return true; + } + + /** + * __toString() magic method + * + * @access public + * @return string + */ + public function __toString() + { + PuTTY::setComment($this->comment); + OpenSSH::setComment($this->comment); + + if ($this->key instanceof PublicKey) { + return $this->key->toString(self::const2str($this->publicKeyFormat)); + } + + if ($this->key instanceof PrivateKey) { + try { + return $this->key->toString(self::const2str($this->privateKeyFormat)); + } catch (UnsupportedFormatException $e) { + if ($this->password) { + return $this->key->withPassword()->toString(self::const2str($this->privateKeyFormat)); + } + } + } + + return ''; + } + + /** + * 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. phpseclib tries to guess if the key being used + * is the public key but in the event that it guesses incorrectly you might still want to explicitly set the key as being + * public. + * + * Do note that when a new key is loaded the index will be cleared. + * + * Returns true on success, false on failure + * + * @see self::getPublicKey() + * @access public + * @param string $key optional + * @param int $type optional + * @return bool + */ + public function setPublicKey() + { + return false; + } + + /** + * Defines the private key + * + * If phpseclib guessed a private key was a public key and loaded it as such it might be desirable to force + * phpseclib to treat the key as a private key. This function will do that. + * + * Do note that when a new key is loaded the index will be cleared. + * + * Returns true on success, false on failure + * + * @see self::getPublicKey() + * @access public + * @param string $key optional + * @param int $type optional + * @return bool + */ + public function setPrivateKey($key = false) + { + if ($key === false && $this->key instanceof RSA2) { + $this->key = $this->key->asPrivateKey(); + } + + try { + $key = PublicKeyLoader::load($key); + } catch (NoKeyLoadedException $e) { + return false; + } + if ($key instanceof RSA2) { + $this->key = $key instanceof PublicKey ? $key->asPrivateKey() : $key; + return true; + } + + return false; + } + + /** + * 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 self::getPublicKey() + * @access public + * @param string $key + * @param int $type optional + */ + public function getPublicKey($type = self::PUBLIC_FORMAT_PKCS8) + { + PuTTY::setComment($this->comment); + OpenSSH::setComment($this->comment); + + if ($this->key instanceof PrivateKey) { + return $this->key->getPublicKey()->toString(self::const2str($type)); + } + + if ($this->key instanceof PublicKey) { + return $this->key->toString(self::const2str($type)); + } + + return false; + } + + /** + * Returns the public key's fingerprint + * + * The public key's fingerprint is returned, which is equivalent to running `ssh-keygen -lf rsa.pub`. If there is + * no public key currently loaded, false is returned. + * Example output (md5): "c1:b1:30:29:d7:b8:de:6c:97:77:10:d7:46:41:63:87" (as specified by RFC 4716) + * + * @access public + * @param string $algorithm The hashing algorithm to be used. Valid options are 'md5' and 'sha256'. False is returned + * for invalid values. + * @return mixed + */ + public function getPublicKeyFingerprint($algorithm = 'md5') + { + if ($this->key instanceof PublicKey) { + return $this->key->getFingerprint($algorithm); + } + + return false; + } + + /** + * Returns the private key + * + * The private key is only returned if the currently loaded key contains the constituent prime numbers. + * + * @see self::getPublicKey() + * @access public + * @param string $key + * @param int $type optional + * @return mixed + */ + public function getPrivateKey($type = self::PUBLIC_FORMAT_PKCS1) + { + PuTTY::setComment($this->comment); + OpenSSH::setComment($this->comment); + + if ($this->key instanceof PrivateKey) { + try { + return $this->key->toString(self::const2str($this->privateKeyFormat)); + } catch (UnsupportedFormatException $e) { + if ($this->password) { + return $this->key->withPassword()->toString(self::const2str($this->privateKeyFormat)); + } + } + + } + + return false; + } + + /** + * __clone() magic method + * + * @access public + * @return Crypt_RSA + */ + public function __clone() + { + $key = new RSA(); + $key->loadKey($this); + return $key; + } + + /** + * Convert phpseclib 2.0 style constants to phpseclib 3.0 style strings + * + * @param int $const + * @access private + * @return string + */ + private static function const2str($const) + { + switch ($const) { + case self::PRIVATE_FORMAT_PKCS1: + case self::PUBLIC_FORMAT_PKCS1: + return 'PKCS1'; + case self::PRIVATE_FORMAT_PUTTY: + return 'PuTTY'; + case self::PRIVATE_FORMAT_XML: + case self::PUBLIC_FORMAT_XML: + return 'XML'; + case self::PRIVATE_FORMAT_PKCS8: + case self::PUBLIC_FORMAT_PKCS8: + return 'PKCS8'; + case self::PRIVATE_FORMAT_OPENSSH: + case self::PUBLIC_FORMAT_OPENSSH: + return 'OpenSSH'; + } + } + + /** + * Determines the private key format + * + * @see self::createKey() + * @access public + * @param int $format + */ + public function setPrivateKeyFormat($format) + { + $this->privateKeyFormat = $format; + } + + /** + * Determines the public key format + * + * @see self::createKey() + * @access public + * @param int $format + */ + public function setPublicKeyFormat($format) + { + $this->publicKeyFormat = $format; + } + + /** + * Determines which hashing function should be used + * + * Used with signature production / verification and (if the encryption mode is self::ENCRYPTION_OAEP) encryption and + * decryption. If $hash isn't supported, sha1 is used. + * + * @access public + * @param string $hash + */ + public function setHash($hash) + { + $this->hash = $hash; + if ($this->key instanceof AsymmetricKey) { + try { + $this->key = $this->key->withHash($hash); + } catch (UnsupportedAlgorithmException $e) { + $this->key = $this->key->withHash('sha1'); + } + } + } + + /** + * Determines which hashing function should be used for the mask generation function + * + * The mask generation function is used by self::ENCRYPTION_OAEP and self::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 + */ + public function setMGFHash($hash) + { + $this->mgfHash = $hash; + if ($this->key instanceof RSA2) { + try { + $this->key = $this->key->withMGFHash($hash); + } catch (UnsupportedAlgorithmException $e) { + $this->key = $this->key->withMGFHash('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 int $format + */ + public function setSaltLength($sLen) + { + $this->sLen = $sLen; + if ($this->key instanceof RSA2) { + $this->key = $this->key->withSaltLength($sLen); + } + } + + /** + * Set Encryption Mode + * + * Valid values include self::ENCRYPTION_OAEP and self::ENCRYPTION_PKCS1. + * + * @access public + * @param int $mode + */ + public function setEncryptionMode($mode) + { + $this->encryptionMode = $mode; + if ($this->key instanceof RSA2) { + $this->key = $this->key->withPadding( + self::enc2pad($this->encryptionMode) | + self::sig2pad($this->signatureMode) + ); + } + } + + /** + * Set Signature Mode + * + * Valid values include self::SIGNATURE_PSS and self::SIGNATURE_PKCS1 + * + * @access public + * @param int $mode + */ + public function setSignatureMode($mode) + { + $this->signatureMode = $mode; + if ($this->key instanceof RSA2) { + $this->key = $this->key->withPadding( + self::enc2pad($this->encryptionMode) | + self::sig2pad($this->signatureMode) + ); + } + } + + /** + * Convert phpseclib 2.0 style constants to phpseclib 3.0 style constants + * + * @param int $mode + * @access private + * @return int + */ + private function enc2pad($mode) + { + switch ($mode) { + case self::ENCRYPTION_PKCS1: + return RSA2::ENCRYPTION_PKCS1; + case self::ENCRYPTION_NONE: + return RSA2::ENCRYPTION_NONE; + //case self::ENCRYPTION_OAEP: + default: + return RSA2::ENCRYPTION_OAEP; + } + } + + /** + * Convert phpseclib 2.0 style constants to phpseclib 3.0 style constants + * + * @param int $mode + * @access private + * @return int + */ + private function sig2pad($mode) + { + switch ($mode) { + case self::SIGNATURE_PKCS1: + return RSA2::SIGNATURE_PKCS1; + //case self::SIGNATURE_PSS: + default: + return RSA2::SIGNATURE_PSS; + } + } + + /** + * Set public key comment. + * + * @access public + * @param string $comment + */ + public function setComment($comment) + { + $this->comment = $comment; + } + + /** + * Get public key comment. + * + * @access public + * @return string + */ + public function getComment() + { + // we'd need to make the load method in the parent PuTTY and OpenSSH classes public instead of protected + // for this to work + try { + $key = PuTTY::load($this->origKey); + return $key['comment']; + } catch (\Exception $e) {} + + try { + $key = OpenSSH::load($this->origKey); + return $key['comment']; + } catch (\Exception $e) {} + + return ''; + } + + /** + * Encryption + * + * Both self::ENCRYPTION_OAEP and self::ENCRYPTION_PKCS1 both place limits on how long $plaintext can be. + * If $plaintext exceeds those limits it will be broken up so that it does and the resultant ciphertext's will + * be concatenated together. + * + * @see self::decrypt() + * @access public + * @param string $plaintext + * @return string + */ + public function encrypt($plaintext) + { + if (!$this->key instanceof RSA2) { + return false; + } + $key = $this->key; + if ($key instanceof PrivateKey) { + $key = $key->toString('Raw'); + $temp = new static(); + $temp->loadKey(['e' => $key['d'], 'n' => $key['n']]); + $key = $temp->key; + } + if ($key instanceof PublicKey) { + switch ($this->encryptionMode) { + case self::ENCRYPTION_PKCS1: + $len = ($key->getLength() - 88) >> 3; + break; + case self::ENCRYPTION_NONE: + $len = $key->getLength() >> 3; + break; + //case self::ENCRYPTION_OAEP: + default: + $len = ($key->getLength() - 2 * $key->getHash()->getLength() - 16) >> 3; + } + $plaintext = str_split($plaintext, $len); + $ciphertext = ''; + foreach ($plaintext as $m) { + $ciphertext.= $key->encrypt($m); + } + return $ciphertext; + } + + return false; + } + + /** + * Decryption + * + * @see self::encrypt() + * @access public + * @param string $plaintext + * @return string + */ + public function decrypt($ciphertext) + { + if (!$this->key instanceof RSA2) { + return false; + } + $key = $this->key; + if ($key instanceof PublicKey) { + $key = $key->asPrivateKey(); + } + if ($key instanceof PrivateKey) { + $len = $key->getLength() >> 3; + $ciphertext = str_split($ciphertext, $len); + $ciphertext[count($ciphertext) - 1] = str_pad($ciphertext[count($ciphertext) - 1], $len, chr(0), STR_PAD_LEFT); + + $plaintext = ''; + foreach ($ciphertext as $c) { + try { + $plaintext.= $key->decrypt($c); + } catch (\Exception $e) { + return false; + } + } + return $plaintext; + } + + return false; + } + + /** + * Create a signature + * + * @see self::verify() + * @access public + * @param string $message + * @return string + */ + public function sign($message) + { + if ($this->key instanceof PrivateKey) { + return $this->key->sign($message); + } + + return false; + } + + /** + * Verifies a signature + * + * @see self::sign() + * @access public + * @param string $message + * @param string $signature + * @return bool + */ + public function verify($message, $signature) + { + if ($this->key instanceof PublicKey) { + return $this->key->verify($message, $signature); + } + + return false; + } + + /** + * Returns a public key object + * + * @access public + * @return AsymmetricKey|false + */ + public function getKeyObject() + { + return $this->key; + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/Random.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Random.php new file mode 100644 index 000000000..49a281b3d --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Random.php @@ -0,0 +1,36 @@ +<?php + +/** + * Random Number Generator + * + * PHP version 5 + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * echo bin2hex(\phpseclib\Crypt\Random::string(8)); + * ?> + * </code> + * + * @category Crypt + * @package Random + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP Random Number Generator + * + * @package Random + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class Random extends \phpseclib3\Crypt\Random +{ +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/Rijndael.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Rijndael.php new file mode 100644 index 000000000..f3b9a7df8 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Rijndael.php @@ -0,0 +1,137 @@ +<?php + +/** + * Pure-PHP implementation of Rijndael. + * + * Uses mcrypt, if available/possible, and an internal implementation, otherwise. + * + * PHP version 5 + * + * If {@link self::setBlockLength() setBlockLength()} isn't called, it'll be assumed to be 128 bits. If + * {@link self::setKeyLength() setKeyLength()} isn't called, it'll be calculated from + * {@link self::setKey() setKey()}. ie. if the key is 128-bits, the key length will be 128-bits. If it's + * 136-bits it'll be null-padded to 192-bits and 192 bits will be the key length until + * {@link self::setKey() setKey()} is called, again, at which point, it'll be recalculated. + * + * Not all Rijndael implementations may support 160-bits or 224-bits as the block length / key length. mcrypt, for example, + * does not. AES, itself, only supports block lengths of 128 and key lengths of 128, 192, and 256. + * {@link http://csrc.nist.gov/archive/aes/rijndael/Rijndael-ammended.pdf#page=10 Rijndael-ammended.pdf#page=10} defines the + * algorithm for block lengths of 192 and 256 but not for block lengths / key lengths of 160 and 224. Indeed, 160 and 224 + * are first defined as valid key / block lengths in + * {@link http://csrc.nist.gov/archive/aes/rijndael/Rijndael-ammended.pdf#page=44 Rijndael-ammended.pdf#page=44}: + * Extensions: Other block and Cipher Key lengths. + * Note: Use of 160/224-bit Keys must be explicitly set by setKeyLength(160) respectively setKeyLength(224). + * + * {@internal The variable names are the same as those in + * {@link http://www.csrc.nist.gov/publications/fips/fips197/fips-197.pdf#page=10 fips-197.pdf#page=10}.}} + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $rijndael = new \phpseclib\Crypt\Rijndael(); + * + * $rijndael->setKey('abcdefghijklmnop'); + * + * $size = 10 * 1024; + * $plaintext = ''; + * for ($i = 0; $i < $size; $i++) { + * $plaintext.= 'a'; + * } + * + * echo $rijndael->decrypt($rijndael->encrypt($plaintext)); + * ?> + * </code> + * + * @category Crypt + * @package Rijndael + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2008 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementation of Rijndael. + * + * @package Rijndael + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class Rijndael extends Base +{ + /** + * Sets the block length + * + * Valid block lengths are 128, 160, 192, 224, and 256. If the length is less than 128, it will be rounded up to + * 128. If the length is greater than 128 and invalid, it will be rounded down to the closest valid amount. + * + * @access public + * @param int $length + */ + public function setBlockLength($length) + { + $length >>= 5; + if ($length > 8) { + $length = 8; + } elseif ($length < 4) { + $length = 4; + } + $this->cipher->setBlockLength($length); + } + + /** + * Turns key lengths, be they valid or invalid, to valid key lengths + * + * @param int $length + * @access private + * @return int + */ + protected function calculateNewKeyLength($length) + { + switch (true) { + case $length <= 128: + return 128; + case $length <= 160: + return 160; + case $length <= 192: + return 192; + case $length <= 224: + return 224; + default: + return 256; + } + } + + /** + * Sets the password. + * + * Depending on what $method is set to, setPassword()'s (optional) parameters are as follows: + * {@link http://en.wikipedia.org/wiki/PBKDF2 pbkdf2} or pbkdf1: + * $hash, $salt, $count, $dkLen + * + * Where $hash (default = sha1) currently supports the following hashes: see: Crypt/Hash.php + * + * @see Crypt/Hash.php + * @param string $password + * @param string $method + * @return bool + * @access public + * @internal Could, but not must, extend by the child Crypt_* class + */ + public function setPassword($password, $method = 'pbkdf2') + { + $this->cipher->setKeyLength($this->key_length); + $args = func_get_args(); + if (in_array($method, ['pbkdf1', 'pbkdf2']) && !isset($args[3])) { + $args[1] = $method; + $args[2] = isset($args[2]) ? $args[2] : 'sha1'; + $args[3] = 'phpseclib'; + } + $this->password = $args; + $this->cipher->setPassword(...$args); + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/TripleDES.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/TripleDES.php new file mode 100644 index 000000000..d66dc74d6 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/TripleDES.php @@ -0,0 +1,116 @@ +<?php + +/** + * Pure-PHP implementation of Triple DES. + * + * Uses mcrypt, if available, and an internal implementation, otherwise. Operates in the EDE3 mode (encrypt-decrypt-encrypt). + * + * PHP version 5 + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $des = new \phpseclib\Crypt\TripleDES(); + * + * $des->setKey('abcdefghijklmnopqrstuvwx'); + * + * $size = 10 * 1024; + * $plaintext = ''; + * for ($i = 0; $i < $size; $i++) { + * $plaintext.= 'a'; + * } + * + * echo $des->decrypt($des->encrypt($plaintext)); + * ?> + * </code> + * + * @category Crypt + * @package TripleDES + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementation of Triple DES. + * + * @package TripleDES + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class TripleDES extends Base +{ + /** + * Encrypt / decrypt using inner chaining + * + * Inner chaining is used by SSH-1 and is generally considered to be less secure then outer chaining (self::MODE_CBC3). + */ + const MODE_3CBC = -2; + + /** + * Encrypt / decrypt using outer chaining + * + * Outer chaining is used by SSH-2 and when the mode is set to \phpseclib\Crypt\Base::MODE_CBC. + */ + const MODE_CBC3 = Base::MODE_CBC; + + /** + * Default Constructor. + * + * Determines whether or not the mcrypt extension should be used. + * + * $mode could be: + * + * - \phpseclib\Crypt\Base::MODE_ECB + * + * - \phpseclib\Crypt\Base::MODE_CBC + * + * - \phpseclib\Crypt\Base::MODE_CTR + * + * - \phpseclib\Crypt\Base::MODE_CFB + * + * - \phpseclib\Crypt\Base::MODE_OFB + * + * - \phpseclib\Crypt\TripleDES::MODE_3CBC + * + * If not explicitly set, \phpseclib\Crypt\Base::MODE_CBC will be used. + * + * @see \phpseclib\Crypt\DES::__construct() + * @see \phpseclib\Crypt\Base::__construct() + * @param int $mode + * @access public + */ + public function __construct($mode = self::MODE_CBC) + { + if ($mode == self::MODE_3CBC) { + $this->cipher = new \phpseclib3\Crypt\TripleDES('3cbc'); + $this->key_length = $this->cipher->getKeyLength(); + return; + } + parent::__construct($mode); + } + + /** + * Turns key lengths, be they valid or invalid, to valid key lengths + * + * @param int $length + * @access private + * @return int + */ + protected function calculateNewKeyLength($length) + { + switch (true) { + case $length <= 64: + return 64; + case $length <= 128: + return 128; + default: + return 192; + } + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Crypt/Twofish.php b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Twofish.php new file mode 100644 index 000000000..f57c54c9d --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Crypt/Twofish.php @@ -0,0 +1,67 @@ +<?php + +/** + * Pure-PHP implementation of Twofish. + * + * Uses mcrypt, if available, and an internal implementation, otherwise. + * + * PHP version 5 + * + * Useful resources are as follows: + * + * - {@link http://en.wikipedia.org/wiki/Twofish Wikipedia description of Twofish} + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $twofish = new \phpseclib\Crypt\Twofish(); + * + * $twofish->setKey('12345678901234567890123456789012'); + * + * $plaintext = str_repeat('a', 1024); + * + * echo $twofish->decrypt($twofish->encrypt($plaintext)); + * ?> + * </code> + * + * @category Crypt + * @package Twofish + * @author Jim Wigginton <terrafrost@php.net> + * @author Hans-Juergen Petrich <petrich@tronic-media.com> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Crypt; + +/** + * Pure-PHP implementation of Twofish. + * + * @package Twofish + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class Twofish extends Base +{ + /** + * Turns key lengths, be they valid or invalid, to valid key lengths + * + * @param int $length + * @access private + * @return int + */ + protected function calculateNewKeyLength($length) + { + switch (true) { + case $length <= 128: + return 128; + case $length <= 192: + return 192; + default: + return 256; + } + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/File/ANSI.php b/vendor/phpseclib/phpseclib2_compat/src/File/ANSI.php new file mode 100644 index 000000000..73bbb8a24 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/File/ANSI.php @@ -0,0 +1,32 @@ +<?php + +/** + * Pure-PHP ANSI Decoder + * + * PHP version 5 + * + * If you call read() in \phpseclib\Net\SSH2 you may get {@link http://en.wikipedia.org/wiki/ANSI_escape_code ANSI escape codes} back. + * They'd look like chr(0x1B) . '[00m' or whatever (0x1B = ESC). They tell a + * {@link http://en.wikipedia.org/wiki/Terminal_emulator terminal emulator} how to format the characters, what + * color to display them in, etc. \phpseclib\File\ANSI is a {@link http://en.wikipedia.org/wiki/VT100 VT100} terminal emulator. + * + * @category File + * @package ANSI + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2012 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\File; + +/** + * Pure-PHP ANSI Decoder + * + * @package ANSI + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class ANSI extends \phpseclib3\File\ANSI +{ +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/File/ASN1.php b/vendor/phpseclib/phpseclib2_compat/src/File/ASN1.php new file mode 100644 index 000000000..ceecf7c0e --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/File/ASN1.php @@ -0,0 +1,95 @@ +<?php + +/** + * Pure-PHP ASN.1 Parser + * + * PHP version 5 + * + * ASN.1 provides the semantics for data encoded using various schemes. The most commonly + * utilized scheme is DER or the "Distinguished Encoding Rules". PEM's are base64 encoded + * DER blobs. + * + * \phpseclib\File\ASN1 decodes and encodes DER formatted messages and places them in a semantic context. + * + * Uses the 1988 ASN.1 syntax. + * + * @category File + * @package ASN1 + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2012 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\File; + +/** + * Pure-PHP ASN.1 Parser + * + * @package ASN1 + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class ASN1 extends \phpseclib3\File\ASN1 +{ + /** + * Parse BER-encoding + * + * Serves a similar purpose to openssl's asn1parse + * + * @param string $encoded + * @return array + * @access public + */ + public static function decodeBER($encoded) + { + $decoded = parent::decodeBER($encoded); + if ($decoded === null) { + return [false]; + } + return $decoded; + } + + /** + * BER-decode the OID + * + * Called by _decode_ber() + * + * @access private + * @param string $content + * @return string + */ + public function _decodeOID($content) + { + return $this->decodeOID($content); + } + + /** + * 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 paragraph 8.1.3} for more information. + * + * @access private + * @param int $length + * @return string + */ + public function _encodeLength($length) + { + return $this->encodeLength($length); + } + + /** + * DER-encode the OID + * + * Called by _encode_der() + * + * @access private + * @param string $content + * @return string + */ + public function _encodeOID($source) + { + return $this->encodeOID($source); + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/File/ASN1/Element.php b/vendor/phpseclib/phpseclib2_compat/src/File/ASN1/Element.php new file mode 100644 index 000000000..fe1871eb3 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/File/ASN1/Element.php @@ -0,0 +1,28 @@ +<?php +/** + * Pure-PHP ASN.1 Parser + * + * PHP version 5 + * + * @category File + * @package ASN1 + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2012 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\File\ASN1; + +/** + * ASN.1 Element + * + * Bypass normal encoding rules in phpseclib\File\ASN1::encodeDER() + * + * @package ASN1 + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class Element extends \phpseclib3\File\ASN1\Element +{ +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/File/X509.php b/vendor/phpseclib/phpseclib2_compat/src/File/X509.php new file mode 100644 index 000000000..e285ab0b9 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/File/X509.php @@ -0,0 +1,407 @@ +<?php + +/** + * Pure-PHP X.509 Parser + * + * PHP version 5 + * + * Encode and decode X.509 certificates. + * + * The extensions are from {@link http://tools.ietf.org/html/rfc5280 RFC5280} and + * {@link http://web.archive.org/web/19961027104704/http://www3.netscape.com/eng/security/cert-exts.html Netscape Certificate Extensions}. + * + * Note that loading an X.509 certificate and resaving it may invalidate the signature. The reason being that the signature is based on a + * portion of the certificate that contains optional parameters with default values. ie. if the parameter isn't there the default value is + * used. Problem is, if the parameter is there and it just so happens to have the default value there are two ways that that parameter can + * be encoded. It can be encoded explicitly or left out all together. This would effect the signature value and thus may invalidate the + * the certificate all together unless the certificate is re-signed. + * + * @category File + * @package X509 + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2012 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\File; + +use phpseclib\Crypt\RSA; +use phpseclib3\File\ASN1\Element as NewElement; +use phpseclib\File\ASN1\Element as OldElement; + +/** + * Pure-PHP X.509 Parser + * + * @package X509 + * @method bool|mixed[] loadX509(string $cert, int $mode = X509::FORMAT_AUTO_DETECT) + * @method string|false saveX509(mixed[] $cert, int $format = X509::FORMAT_PEM) + * @method bool loadCA(string $cert) + * @method bool validateURL(string $url) + * @method bool validateDate(\DateTimeInterface|string $date = null) + * @method ?bool validateSignature(bool $caonly = true) + * @method static void setRecurLimit(int $count) + * @method static void disableURLFetch() + * @method static void enableURLFetch() + * @method static string decodeIP(string $ip) + * @method static array{bool|string, bool|string} decodeNameConstraintIP(string $ip) + * @method static string encodeIP(string|array{string, string} $ip) + * @method bool setDNProp(string $propName, mixed $propValue, string $type = 'utf8String') + * @method void removeDNProp(string $propName) + * @method mixed[] getDNProp(string $propName, mixed[] $dn, bool $withType = false) + * @method bool setDN(mixed $dn, bool $merge = false, string $type = 'utf8String') + * @method mixed getDN(int $format = X509::DN_ARRAY, mixed[] $dn = null) + * @method mixed getIssuerDN(int $format = X509::DN_ARRAY) + * @method mixed getSubjectDN(int $format = X509::DN_ARRAY) + * @method mixed getIssuerDNProp(string $propName, bool $withType = false) + * @method mixed getSubjectDNProp(string $propName, bool $withType = false) + * @method mixed[] getChain() + * @method bool|mixed[] getCurrentCert() + * @method void setChallenge(string $challenge) + * @method PublicKey|false getPublicKey() + * @method bool|mixed[] loadCSR(string $csr, int $mode = X509::FORMAT_AUTO_DETECT) + * @method string|false saveCSR(array $csr, int $format = X509::FORMAT_PEM) + * @method bool|mixed[] loadSPKAC(string $spkac) + * @method string|false saveSPKAC(array $spkac, int $format = X509::FORMAT_PEM) + * @method bool|mixed[] loadCRL(string $crl, int $mode = X509::FORMAT_AUTO_DETECT) + * @method string|false saveCRL(array $crl, int $format = X509::FORMAT_PEM) + * @method bool|mixed[] sign(X509 $issuer, X509 $subject) + * @method bool|mixed[] signCSR() + * @method bool|mixed[] signSPKAC() + * @method bool|mixed[] signCRL(X509 $issuer, X509 $crl) + * @method void setStartDate(\DateTimeInterface|string $date) + * @method void setEndDate(\DateTimeInterface|string $date) + * @method void setSerialNumber(string $serial, int $base = -256) + * @method void makeCA() + * @method bool removeExtension(string $id) + * @method mixed getExtension(string $id, mixed[] $cert = null, string $path = null) + * @method mixed[] getExtension(mixed[] $cert = null, string $path = null) + * @method bool setExtension(mixed[] $cert = null, mixed $value, string $path = null) + * @method bool removeAttribute(string $id, int $disposition = X509::ATTR_ALL) + * @method mixed getAttribute(string $id, int $disposition = X509::ATTR_ALL, array $csr = null) + * @method mixed[] getAttributes(mixed[] $csr = null) + * @method void setKeyIdentifier(string $value) + * @method mixed computeKeyIdentifier(mixed $key = null, int $method = 1) + * @method void setDomain(string ...$domains) + * @method void setIPAddress(mixed ...$ipAddresses) + * @method bool revoke(string $serial, string $date = null) + * @method bool unrevoke(string $serial) + * @method mixed getRevoked(string $serial) + * @method mixed[] listRevoked(mixed[] $crl = null) + * @method bool removeRevokedCertificateExtension(string $serial, string $id) + * @method mixed getRevokedCertificateExtension(string $serial, string $id, mixed[] $crl = null) + * @method bool|mixed[] getRevokedCertificateExtensions(string $serial, mixed[] $crl = null) + * @method bool setRevokedCertificateExtension(string $serial, string $id, $value, bool $critical = false, bool $replace = true) + * @method static void registerExtension(string $id, mixed[] $mapping) + * @method static ?mixed[] getRegisteredExtension(string $id) + * @method static void setExtensionValue(string $id, $value, bool $critical = false, bool $replace = false) + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class X509 +{ + /** + * Flag to only accept signatures signed by certificate authorities + * + * Not really used anymore but retained all the same to suppress E_NOTICEs from old installs + * + * @access public + */ + const VALIDATE_SIGNATURE_BY_CA = 1; + + /**#@+ + * @access public + * @see \phpseclib3\File\X509::getDN() + */ + /** + * Return internal array representation + */ + const DN_ARRAY = 0; + /** + * Return string + */ + const DN_STRING = 1; + /** + * Return ASN.1 name string + */ + const DN_ASN1 = 2; + /** + * Return OpenSSL compatible array + */ + const DN_OPENSSL = 3; + /** + * Return canonical ASN.1 RDNs string + */ + const DN_CANON = 4; + /** + * Return name hash for file indexing + */ + const DN_HASH = 5; + /**#@-*/ + + /**#@+ + * @access public + * @see \phpseclib3\File\X509::saveX509() + * @see \phpseclib3\File\X509::saveCSR() + * @see \phpseclib3\File\X509::saveCRL() + */ + /** + * Save as PEM + * + * ie. a base64-encoded PEM with a header and a footer + */ + const FORMAT_PEM = 0; + /** + * Save as DER + */ + const FORMAT_DER = 1; + /** + * Save as a SPKAC + * + * Only works on CSRs. Not currently supported. + */ + const FORMAT_SPKAC = 2; + /** + * Auto-detect the format + * + * Used only by the load*() functions + */ + const FORMAT_AUTO_DETECT = 3; + /**#@-*/ + + /** + * Attribute value disposition. + * If disposition is >= 0, this is the index of the target value. + */ + const ATTR_ALL = -1; // All attribute values (array). + const ATTR_APPEND = -2; // Add a value. + const ATTR_REPLACE = -3; // Clear first, then add a value. + + /** + * The X509 object + * + * @var \phpseclib3\File\X509 + * @access private + */ + private $x509; + + /** + * Default Constructor. + * + * @return \phpseclib\File\X509 + * @access public + */ + public function __construct() + { + // we don't extend phpseclib3\File\X509 because the setPublicKey() and setPrivateKey() methods + // have different method signatures + $this->x509 = new \phpseclib3\File\X509(); + } + + /** + * __call() magic method + * + * @access public + */ + public function __call($name, $args) + { + foreach ($args as &$arg) { + if ($arg instanceof \phpseclib\File\X509) { + $arg = $arg->x509; + } + } + + switch ($name) { + case 'loadX509': + case 'saveX509': + case 'sign': + $part1 = 'tbsCertificate'; + $part2 = 'extensions'; + break; + case 'loadCRL': + case 'saveCRL': + case 'signCRL': + $part1 = 'tbsCertList'; + $part2 = 'crlExtensions'; + break; + case 'loadCSR': + case 'saveCSR': + case 'signCSR': + $part1 = 'certificationRequestInfo'; + $part2 = 'attributes'; + } + + if (isset($args[0])) { + switch ($name) { + case 'saveX509': + case 'saveCRL': + case 'saveCSR': + if (isset($args[0][$part1][$part2])) { + $arr = &$args[0][$part1][$part2]; + if ($part2 == 'attributes') { + foreach ($arr as &$attr) { + if (isset($attr['type']) && $attr['type'] == 'pkcs-9-at-extensionRequest') { + $arr = $attr['value'][0]; + break; + } + } + } + foreach ($arr as &$extension) { + if ($extension instanceof NewElement || !is_array($extension)) { + continue; + } + if (is_string($extension['extnValue'])) { + $extension['extnValue'] = base64_decode($extension['extnValue']); + } + } + } + + if (isset($args[0]['signature'])) { + $args[0]['signature'] = base64_decode($args[0]['signature']); + } + } + } + + $result = $this->x509->$name(...$args); + if ($result instanceof \phpseclib3\File\X509) { + $temp = new static; + $temp->x509 = $result; + return $temp; + } + + if (!is_array($result)) { + return $result; + } + + $result = self::replaceNewElements($result); + + if (!isset($part1)) { + return $result; + } + + if (isset($result[$part1][$part2])) { + $arr = &$result[$part1][$part2]; + if ($part2 == 'attributes') { + foreach ($arr as &$attr) { + if (isset($attr['type']) && $attr['type'] == 'pkcs-9-at-extensionRequest') { + $arr = $attr['value'][0]; + break; + } + } + } + foreach ($arr as &$extension) { + if ($extension instanceof NewElement || !is_array($extension)) { + continue; + } + if (is_string($extension['extnValue'])) { + $extension['extnValue'] = base64_encode($extension['extnValue']); + } + } + } + + if (isset($result['signature'])) { + $result['signature'] = base64_encode($result['signature']); + } + + return $result; + } + + /** + * __callStatic() magic method + * + * @access public + */ + public static function __callStatic($name, $args) + { + return \phpseclib3\File\X509::$name(...$args); + } + + /** + * Set public key + * + * Key needs to be a \phpseclib\Crypt\RSA object + * + * @param object $key + * @access public + * @return bool + */ + public function setPublicKey($key) + { + if (!$key instanceof RSA) { + return; + } + $key = $key->getKeyObject(); + if ($key instanceof \phpseclib3\Crypt\Common\PublicKey) { + if ($key instanceof \phpseclib3\Crypt\RSA) { + $key = $key->withPadding(\phpseclib3\Crypt\RSA::SIGNATURE_PKCS1); + } + $this->x509->setPublicKey($key); + } + } + + /** + * Set private key + * + * Key needs to be a \phpseclib\Crypt\RSA object + * + * @param object $key + * @access public + */ + public function setPrivateKey($key) + { + if (!$key instanceof RSA) { + return; + } + $key = $key->getKeyObject(); + if ($key instanceof \phpseclib3\Crypt\Common\PrivateKey) { + if ($key instanceof \phpseclib3\Crypt\RSA) { + $key = $key->withPadding(\phpseclib3\Crypt\RSA::SIGNATURE_PKCS1); + } + $this->x509->setPrivateKey($key); + } + } + + /** + * Returns the OID corresponding to a name + * + * What's returned in the associative array returned by loadX509() (or load*()) is either a name or an OID if + * no OID to name mapping is available. The problem with this is that what may be an unmapped OID in one version + * of phpseclib may not be unmapped in the next version, so apps that are looking at this OID may not be able + * to work from version to version. + * + * This method will return the OID if a name is passed to it and if no mapping is avialable it'll assume that + * what's being passed to it already is an OID and return that instead. A few examples. + * + * getOID('2.16.840.1.101.3.4.2.1') == '2.16.840.1.101.3.4.2.1' + * getOID('id-sha256') == '2.16.840.1.101.3.4.2.1' + * getOID('zzz') == 'zzz' + * + * @access public + * @return string + */ + public function getOID($name) + { + return \phpseclib3\File\ASN1::getOID($name); + } + + /** + * Replaces \phpseclib3\File\ASN1\Element with \phpseclib\File\ASN1\Element + * + * @return array + */ + private static function replaceNewElements($el) + { + switch (true) { + case $el instanceof NewElement: + return new OldElement($el->element); + case !is_array($el): + return $el; + } + + foreach ($el as &$val) { + $val = self::replaceNewElements($val); + } + + return $el; + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Math/BigInteger.php b/vendor/phpseclib/phpseclib2_compat/src/Math/BigInteger.php new file mode 100644 index 000000000..905d8fe65 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Math/BigInteger.php @@ -0,0 +1,308 @@ +<?php + +/** + * Pure-PHP arbitrary precision integer arithmetic library. + * + * Supports base-2, base-10, base-16, and base-256 numbers. Uses the GMP or BCMath extensions, if available, + * and an internal implementation, otherwise. + * + * PHP version 5 + * + * {@internal (all DocBlock comments regarding implementation - such as the one that follows - refer to the + * {@link self::MODE_INTERNAL self::MODE_INTERNAL} mode) + * + * BigInteger uses base-2**26 to perform operations such as multiplication and division and + * base-2**52 (ie. two base 2**26 digits) to perform addition and subtraction. Because the largest possible + * value when multiplying two base-2**26 numbers together is a base-2**52 number, double precision floating + * point numbers - numbers that should be supported on most hardware and whose significand is 53 bits - are + * used. As a consequence, bitwise operators such as >> and << cannot be used, nor can the modulo operator %, + * which only supports integers. Although this fact will slow this library down, the fact that such a high + * base is being used should more than compensate. + * + * Numbers are stored in {@link http://en.wikipedia.org/wiki/Endianness little endian} format. ie. + * (new \phpseclib\Math\BigInteger(pow(2, 26)))->value = array(0, 1) + * + * Useful resources are as follows: + * + * - {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf Handbook of Applied Cryptography (HAC)} + * - {@link http://math.libtomcrypt.com/files/tommath.pdf Multi-Precision Math (MPM)} + * - Java's BigInteger classes. See /j2se/src/share/classes/java/math in jdk-1_5_0-src-jrl.zip + * + * Here's an example of how to use this library: + * <code> + * <?php + * $a = new \phpseclib\Math\BigInteger(2); + * $b = new \phpseclib\Math\BigInteger(3); + * + * $c = $a->add($b); + * + * echo $c->toString(); // outputs 5 + * ?> + * </code> + * + * @category Math + * @package BigInteger + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2006 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + */ + +namespace phpseclib\Math; + +use phpseclib3\Math\BigInteger as BigInteger2; + +/** + * Pure-PHP arbitrary precision integer arithmetic library. Supports base-2, base-10, base-16, and base-256 + * numbers. + * + * @package BigInteger + * @method string toString() + * @method string toBytes() + * @method string toHex() + * @method string toBits() + * @method BigInteger add(BigInteger $y) + * @method BigInteger subtract(BigInteger $y) + * @method BigInteger multiply(BigInteger $x) + * @method array{BigInteger, BigInteger} divide(BigInteger $x) + * @method BigInteger modInverse(BigInteger $n) + * @method {'gcd': BigInteger, 'x': BigInteger, 'y': BigInteger} extendedGCD(BigInteger $n) + * @method BigInteger gcd(BigInteger $n) + * @method BigInteger abs() + * @method void setPrecision(int $bits) + * @method int|bool getPrecision() + * @method BigInteger powMod(BigInteger $e, BigInteger $n) + * @method BigInteger modPow(BigInteger $e, BigInteger $n) + * @method int compare(BigInteger $y) + * @method bool equals(BigInteger $x) + * @method BigInteger bitwise_not() + * @method BigInteger bitwise_and(BigInteger $x) + * @method BigInteger bitwise_or(BigInteger $x) + * @method BigInteger bitwise_rightShift($shift) + * @method BigInteger bitwise_leftShift($shift) + * @method BigInteger bitwise_leftRotate($shift) + * @method BigInteger bitwise_rightRotate($shift) + * @method {'min': BigInteger, 'max': BigInteger} minMaxBits($bits) + * @method int getLength() + * @method int getLengthInBytes() + * @method bool isPrime(int|bool $t = false) + * @method BigInteger root(int $n = 2) + * @method BigInteger pow(BigInteger $n) + * @method static BigInteger min(BigInteger ...$nums) + * @method static BigInteger max(BigInteger ...$nums) + * @method bool between(BigInteger $min, BigInteger $max) + * @method bool isOdd() + * @method bool testBit(int $x) + * @method bool isNegative() + * @method BigInteger negate() + * @method callable createRecurringModuloFunction() + * @method BigInteger[] bitwise_split(int $split) + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class BigInteger +{ + /**#@+ + * Array constants + * + * Rather than create a thousands and thousands of new BigInteger objects in repeated function calls to add() and + * multiply() or whatever, we'll just work directly on arrays, taking them in as parameters and returning them. + * + * @access private + */ + /** + * $result[self::VALUE] contains the value. + */ + const VALUE = 0; + /** + * $result[self::SIGN] contains the sign. + */ + const SIGN = 1; + /**#@-*/ + + /**#@+ + * @access private + * @see BigInteger::_montgomery() + * @see BigInteger::_barrett() + */ + /** + * Cache constants + * + * $cache[self::VARIABLE] tells us whether or not the cached data is still valid. + */ + const VARIABLE = 0; + /** + * $cache[self::DATA] contains the cached data. + */ + const DATA = 1; + /**#@-*/ + + /**#@+ + * Mode constants. + * + * @access private + * @see BigInteger::__construct() + */ + /** + * To use the pure-PHP implementation + */ + const MODE_INTERNAL = 1; + /** + * To use the BCMath library + * + * (if enabled; otherwise, the internal implementation will be used) + */ + const MODE_BCMATH = 2; + /** + * To use the GMP library + * + * (if present; otherwise, either the BCMath or the internal implementation will be used) + */ + const MODE_GMP = 3; + /**#@-*/ + + /** + * The BigInteger object + * + * @var \phpseclib3\Math\BigInteger + * @access private + */ + private $bigint; + + /** + * Converts base-2, base-10, base-16, and binary strings (base-256) to BigIntegers. + * + * If the second parameter - $base - is negative, then it will be assumed that the number's are encoded using + * two's compliment. The sole exception to this is -10, which is treated the same as 10 is. + * + * Here's an example: + * <code> + * <?php + * $a = new \phpseclib\Math\BigInteger('0x32', 16); // 50 in base-16 + * + * echo $a->toString(); // outputs 50 + * ?> + * </code> + * + * @param $x base-10 number or base-$base number if $base set. + * @param int $base + * @return \phpseclib\Math\BigInteger + * @access public + */ + public function __construct($x = 0, $base = 10) + { + $this->bigint = new BigInteger2($x, $base); + } + + /** + * __call() magic method + * + * @access public + */ + public function __call($name, $args) + { + foreach ($args as &$arg) { + if ($arg instanceof BigInteger) { + $arg = $arg->bigint; + } + } + $result = $this->bigint->$name(...$args); + if (!$result instanceof BigInteger2) { + return $result; + } + + $temp = new static; + $temp->bigint = $result; + + return $temp; + } + + /** + * __toString() magic method + * + * Will be called, automatically, if you're supporting just PHP5. If you're supporting PHP4, you'll need to call + * toString(). + * + * @access public + * @internal Implemented per a suggestion by Techie-Michael - thanks! + */ + public function __toString() + { + return $this->bigint->__toString(); + } + + /** + * __debugInfo() magic method + * + * Will be called, automatically, when print_r() or var_dump() are called + * + * @access public + */ + public function __debugInfo() + { + return $this->bigint->__debugInfo(); + } + + /** + * Generate a random number + * + * Returns a random number between $min and $max where $min and $max + * can be defined using one of the two methods: + * + * $min->random($max) + * $max->random($min) + * + * @param \phpseclib\Math\BigInteger $arg1 + * @param \phpseclib\Math\BigInteger $arg2 + * @return \phpseclib\Math\BigInteger + * @access public + * @internal The API for creating random numbers used to be $a->random($min, $max), where $a was a BigInteger object. + * That method is still supported for BC purposes. + */ + public function random($arg1, $arg2 = false) + { + $temp = new static; + $temp->bigint = BigInteger2::randomRange( + $arg1->bigint, + $arg2 instanceof BigInteger ? $arg2->bigint : $this->bigint + ); + return $temp; + } + + /** + * Generate a random prime number. + * + * If there's not a prime within the given range, false will be returned. + * If more than $timeout seconds have elapsed, give up and return false. + * + * @param \phpseclib\Math\BigInteger $arg1 + * @param \phpseclib\Math\BigInteger $arg2 + * @return Math_BigInteger|false + * @access public + * @internal See {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap4.pdf#page=15 HAC 4.44}. + */ + public function randomPrime($arg1, $arg2 = false) + { + $temp = new static; + $temp->bigint = BigInteger2::randomRange( + $arg1->bigint, + $arg2 instanceof BigInteger ? $arg2->bigint : $this->bigint + ); + return $temp; + } + + /** + * Logical Exclusive-Or + * + * See https://github.com/phpseclib/phpseclib/issues/1245 for more context + * + * @param \phpseclib\Math\BigInteger $x + * @access public + * @return \phpseclib\Math\BigInteger + */ + public function bitwise_xor($x) + { + $temp = new static; + $temp->bigint = $this->bigint->abs()->bitwise_xor($x->bigint->abs()); + return $temp; + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Net/SFTP.php b/vendor/phpseclib/phpseclib2_compat/src/Net/SFTP.php new file mode 100644 index 000000000..fab1f7219 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Net/SFTP.php @@ -0,0 +1,276 @@ +<?php + +/** + * Pure-PHP implementation of SFTP. + * + * PHP version 5 + * + * Currently only supports SFTPv2 and v3, which, according to wikipedia.org, "is the most widely used version, + * implemented by the popular OpenSSH SFTP server". If you want SFTPv4/5/6 support, provide me with access + * to an SFTPv4/5/6 server. + * + * The API for this library is modeled after the API from PHP's {@link http://php.net/book.ftp FTP extension}. + * + * Here's a short example of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $sftp = new \phpseclib\Net\SFTP('www.domain.tld'); + * if (!$sftp->login('username', 'password')) { + * exit('Login Failed'); + * } + * + * echo $sftp->pwd() . "\r\n"; + * $sftp->put('filename.ext', 'hello, world!'); + * print_r($sftp->nlist()); + * ?> + * </code> + * + * @category Net + * @package SFTP + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2009 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Net; + +use phpseclib\Crypt\RSA; + +/** + * Pure-PHP implementation of SFTP. + * + * @package SFTP + * @method void disableStatCache() + * @method void enableStatCache() + * @method void clearStatCache() + * @method void enablePathCanonicalization() + * @method void disablePathCanonicalization() + * @method void enableArbitraryLengthPackets() + * @method void disableArbitraryLengthPackets() + * @method string|false pwd() + * @method string|false realpath(string $path) + * @method bool chdir(string $dir) + * @method string[]|false nlist(string $dir = '.', bool $recursive = false) + * @method mixed[]|false rawlist(string $dir = '.', bool $recursive = false) + * @method void setListOrder(mixed ...$args) + * @method mixed[]|false stat(string $filename) + * @method mixed[]|false lstat(string $filename) + * @method bool truncate(string $filename, int $new_size) + * @method bool touch(string $filename, int $time = null, int $atime = null) + * @method bool chown(string $filename, int|string $uid, bool $recursive = false) + * @method bool chgrp(string $filename, int|string $gid, bool $recursive = false) + * @method bool chmod(int $mode, string $filename, bool $recursive = false) + * @method mixed readlink(string $link) + * @method bool symlink(string $target, string $link) + * @method bool mkdir(string $dir, int $mode = -1, bool $recursive = false) + * @method bool rmdir(string $dir) + * @method bool put(string $remote_file, string $data, int $mode = SFTP::SOURCE_STRING, int $start = -1, int $local_start = -1, ?callable $progressCallback = null) + * @method string|bool get(string $remote_file, string $local_file = false, int $offset = 0, int $length = -1, ?callable $progressCallback = null) + * @method bool delete(string $path, bool $recursive = true) + * @method bool file_exists(string $path) + * @method bool is_dir(string $path) + * @method bool is_file(string $path) + * @method bool is_link(string $path) + * @method bool is_readable(string $path) + * @method bool is_writable(string $path) + * @method bool is_writeable(string $path) + * @method int|float|false fileatime(string $path) + * @method int|float|false filemtime(string $path) + * @method int|false fileperms(string $path) + * @method int|false fileowner(string $path) + * @method int|false filegroup(string $path) + * @method int|float|false filesize(string $path) + * @method string|false filetype(string $path) + * @method bool rename(string $oldname, string $newname) + * @method string[]|string getSFTPLog() + * @method string[] getSFTPErrors() + * @method string getLastSFTPError() + * @method mixed[]|false getSupportedVersions() + * @method int|false getNegotiatedVersion() + * @method void setPreferredVersion(int $version) + * @method void enableDatePreservation() + * @method void disableDatePreservation() + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class SFTP +{ + /**#@+ + * @access public + * @see \phpseclib\Net\SFTP::put() + */ + /** + * Reads data from a local file. + */ + const SOURCE_LOCAL_FILE = 1; + /** + * Reads data from a string. + */ + // this value isn't really used anymore but i'm keeping it reserved for historical reasons + const SOURCE_STRING = 2; + /** + * Reads data from callback: + * function callback($length) returns string to proceed, null for EOF + */ + const SOURCE_CALLBACK = 16; + /** + * Resumes an upload + */ + const RESUME = 4; + /** + * Append a local file to an already existing remote file + */ + const RESUME_START = 8; + /**#@-*/ + + /** + * The SFTP object + * + * @var \phpseclib3\File\SFTP + * @access private + */ + private $sftp = null; + + /** + * Default Constructor. + * + * Connects to an SFTP server + * + * @param string $host + * @param int $port + * @param int $timeout + * @return \phpseclib\Net\SFTP + * @access public + */ + function __construct($host, $port = 22, $timeout = 10) + { + $this->sftp = new \phpseclib3\Net\SFTP($host, $port, $timeout); + } + + /** + * Login + * + * The $password parameter can be a plaintext password, a \phpseclib3\Crypt\RSA object or an array + * + * @param string $username + * @param $args[] param mixed $password + * @return bool + * @see self::_login() + * @access public + */ + public function login($username, ...$args) + { + foreach ($args as &$arg) { + if ($arg instanceof RSA) { + $arg = $arg->getKeyObject(); + if (!$arg instanceof \phpseclib3\Crypt\Common\PrivateKey) { + return false; + } + } + } + + try { + return $this->sftp->login($username, ...$args); + } catch (\Exception $e) { + user_error($e->getMessage()); + return false; + } + } + + /** + * Parse Attributes + * + * See '7. File Attributes' of draft-ietf-secsh-filexfer-13 for more info. + * + * @param string $response + * @return array + * @access private + */ + protected function parseAttributes(&$response) + { + $r = $this->sftp->parseAttributes($response); + if (isset($r['mode'])) { + $r['permissions'] = $r['mode']; + } + return $r; + } + + /** + * Defines how nlist() and rawlist() will be sorted - if at all. + * + * If sorting is enabled directories and files will be sorted independently with + * directories appearing before files in the resultant array that is returned. + * + * Any parameter returned by stat is a valid sort parameter for this function. + * Filename comparisons are case insensitive. + * + * Examples: + * + * $sftp->setListOrder('filename', SORT_ASC); + * $sftp->setListOrder('size', SORT_DESC, 'filename', SORT_ASC); + * $sftp->setListOrder(true); + * Separates directories from files but doesn't do any sorting beyond that + * $sftp->setListOrder(); + * Don't do any sort of sorting + * + * @param $args[] + * @access public + */ + public function setListOrder(...$args) + { + $sortOptions = []; + if (empty($args)) { + return; + } + $len = count($args) & 0x7FFFFFFE; + for ($i = 0; $i < $len; $i+=2) { + if ($args[$i] == 'permissions') { + $args[$i] = 'mode'; + } + $sortOptions[$args[$i]] = $args[$i + 1]; + } + $this->sftp->setListOrder(...$args); + } + + /** + * Returns the file size, in bytes, or false, on failure + * + * Files larger than 4GB will show up as being exactly 4GB. + * + * @param string $filename + * @return mixed + * @access public + */ + public function size($filename) + { + return $this->sftp->filesize($filename); + } + + /** + * Returns a public key object + * + * @access public + * @return SFTP|false + */ + public function getSFTPObject() + { + return $this->sftp; + } + + /** + * __call() magic method + * + * @access public + */ + public function __call($name, $args) + { + try { + return $this->sftp->$name(...$args); + } catch (\Exception $e) { + user_error($e->getMessage()); + } + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Net/SFTP/Stream.php b/vendor/phpseclib/phpseclib2_compat/src/Net/SFTP/Stream.php new file mode 100644 index 000000000..c456990a7 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Net/SFTP/Stream.php @@ -0,0 +1,75 @@ +<?php + +/** + * SFTP Stream Wrapper + * + * Creates an sftp:// protocol handler that can be used with, for example, fopen(), dir(), etc. + * + * PHP version 5 + * + * @category Net + * @package SFTP + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2013 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + +namespace phpseclib\Net\SFTP; + +use phpseclib\Crypt\RSA; +use phpseclib\Net\SFTP; + +/** + * SFTP Stream Wrapper + * + * @package SFTP + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class Stream extends \phpseclib3\Net\SFTP\Stream +{ + /** + * Path Parser + * + * Extract a path from a URI and actually connect to an SSH server if appropriate + * + * If "notification" is set as a context parameter the message code for successful login is + * NET_SSH2_MSG_USERAUTH_SUCCESS. For a failed login it's NET_SSH2_MSG_USERAUTH_FAILURE. + * + * @param string $path + * @return string + * @access private + */ + protected function parse_path($path) + { + $scheme = parse_url($path, PHP_URL_SCHEME); + if (isset($this->context)) { + $options = stream_context_get_options($this->context); + } + if (isset($options[$scheme]['privkey']) && $options[$scheme]['privkey'] instanceof RSA) { + stream_context_set_option($this->context, $scheme, 'privKey', $options[$scheme]['privkey']->getKeyObject()); + } + if (isset($options[$scheme]['session']) && $options[$scheme]['session'] instanceof SFTP) { + stream_context_set_option($this->context, $scheme, 'session', $options[$scheme]['session']->getSFTPObject()); + } + if (isset($options[$scheme]['sftp']) && $options[$scheme]['sftp'] instanceof SFTP) { + stream_context_set_option($this->context, $scheme, 'sftp', $options[$scheme]['sftp']->getSFTPObject()); + } + return parent::parse_path($path); + } + + /** + * __call() magic method + * + * @access public + */ + public function __call($name, array $args) + { + try { + return parent::__call($name, $args); + } catch (\Exception $e) { + user_error($e->getMessage()); + } + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/Net/SSH2.php b/vendor/phpseclib/phpseclib2_compat/src/Net/SSH2.php new file mode 100644 index 000000000..a78e7e87d --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/Net/SSH2.php @@ -0,0 +1,233 @@ +<?php + +/** + * Pure-PHP implementation of SSHv2. + * + * PHP version 5 + * + * Here are some examples of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $ssh = new \phpseclib\Net\SSH2('www.domain.tld'); + * if (!$ssh->login('username', 'password')) { + * exit('Login Failed'); + * } + * + * echo $ssh->exec('pwd'); + * echo $ssh->exec('ls -la'); + * ?> + * </code> + * + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $key = new \phpseclib\Crypt\RSA(); + * //$key->setPassword('whatever'); + * $key->loadKey(file_get_contents('privatekey')); + * + * $ssh = new \phpseclib\Net\SSH2('www.domain.tld'); + * if (!$ssh->login('username', $key)) { + * exit('Login Failed'); + * } + * + * echo $ssh->read('username@username:~$'); + * $ssh->write("ls -la\n"); + * echo $ssh->read('username@username:~$'); + * ?> + * </code> + * + * @category Net + * @package SSH2 + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2007 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + */ + + +namespace phpseclib\Net; + +use phpseclib\Crypt\RSA; + +/** + * Pure-PHP implementation of SSHv2. + * + * @package SSHv2 + * @method static void setCryptoEngine(string $engine) + * @method void sendIdentificationStringFirst() + * @method void sendIdentificationStringLast() + * @method void sendKEXINITFirst() + * @method void sendKEXINITLast() + * @method int|float getTimeout() + * @method void setTimeout(int|float $timeout) + * @method void setKeepAlive(int|float $interval) + * @method string getStdError() + * @method string|bool exec(string $command, callable ?$callback = null) + * @method bool requestAgentForwarding() + * @method string|bool|null read(string $expect = '', int $mode = SSH2::READ_SIMPLE) + * @method void write(string $cmd) + * @method bool startSubsystem(string $subsystem) + * @method bool stopSubsystem() + * @method void reset() + * @method bool isTimeout() + * @method void disconnect() + * @method bool isConnected() + * @method bool isAuthenticated() + * @method bool ping() + * @method void enableQuietMode() + * @method void disableQuietMode() + * @method bool isQuietModeEnabled() + * @method void enablePTY() + * @method void disablePTY() + * @method bool isPTYEnabled() + * @method array|false|string getLog() + * @method string[] getErrors() + * @method ?string getLastError() + * @method string|false getServerIdentification() + * @method mixed[] getServerAlgorithms() + * @method static string[] getSupportedKEXAlgorithms() + * @method static string[] getSupportedHostKeyAlgorithms() + * @method static string[] getSupportedEncryptionAlgorithms() + * @method static string[] getSupportedMACAlgorithms() + * @method static string[] getSupportedCompressionAlgorithms() + * @method mixed[] getAlgorithmsNegotiated() + * @method void setTerminal(string $term) + * @method void setPreferredAlgorithms(mixed[] $methods) + * @method string getBannerMessage() + * @method string|false getServerPublicHostKey() + * @method false|int getExitStatus() + * @method int getWindowColumns() + * @method int getWindowRows() + * @method setWindowColumns(int $value) + * @method setWindowRows(int $value) + * @method setWindowSize(int $columns = 80, int $rows = 24) + * @method string getResourceId() + * @method static bool|SSH2 getConnectionByResourceId(string $id) + * @method static array<string, SSH2> getConnections() + * @method ?mixed[] getAuthMethodsToContinue() + * @method void enableSmartMFA() + * @method void disableSmartMFA() + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class SSH2 +{ + /**#@+ + * @access public + * @see \phpseclib\Net\SSH2::getLog() + */ + /** + * Returns the message numbers + */ + const LOG_SIMPLE = 1; + /** + * Returns the message content + */ + const LOG_COMPLEX = 2; + /** + * Outputs the content real-time + */ + const LOG_REALTIME = 3; + /** + * Dumps the content real-time to a file + */ + const LOG_REALTIME_FILE = 4; + /** + * Make sure that the log never gets larger than this + */ + const LOG_MAX_SIZE = 1048576; // 1024 * 1024 + /**#@-*/ + + /**#@+ + * @access public + * @see \phpseclib\Net\SSH2::read() + */ + /** + * Returns when a string matching $expect exactly is found + */ + const READ_SIMPLE = 1; + /** + * Returns when a string matching the regular expression $expect is found + */ + const READ_REGEX = 2; + /** + * Returns whenever a data packet is received. + * + * Some data packets may only contain a single character so it may be necessary + * to call read() multiple times when using this option + */ + const READ_NEXT = 3; + /**#@-*/ + + /** + * The SSH2 object + * + * @var \phpseclib3\File\SSH2 + * @access private + */ + private $ssh; + + /** + * Default Constructor. + * + * $host can either be a string, representing the host, or a stream resource. + * + * @param mixed $host + * @param int $port + * @param int $timeout + * @see self::login() + * @return \phpseclib\Net\SSH2 + * @access public + */ + function __construct($host, $port = 22, $timeout = 10) + { + $this->ssh = new \phpseclib3\Net\SSH2($host, $port, $timeout); + } + + /** + * Login + * + * The $password parameter can be a plaintext password, a \phpseclib3\Crypt\RSA object or an array + * + * @param string $username + * @param $args[] param mixed $password + * @return bool + * @see self::_login() + * @access public + */ + public function login($username, ...$args) + { + foreach ($args as &$arg) { + if ($arg instanceof RSA) { + $arg = $arg->getKeyObject(); + if (!$arg) { + return false; + } + } + } + + try { + return $this->ssh->login($username, ...$args); + } catch (\Exception $e) { + user_error($e->getMessage()); + return false; + } + } + + /** + * __call() magic method + * + * @access public + */ + public function __call($name, $args) + { + try { + return $this->ssh->$name(...$args); + } catch (\Exception $e) { + user_error($e->getMessage()); + } + } +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/System/SSH/Agent.php b/vendor/phpseclib/phpseclib2_compat/src/System/SSH/Agent.php new file mode 100644 index 000000000..365353f67 --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/System/SSH/Agent.php @@ -0,0 +1,47 @@ +<?php + +/** + * Pure-PHP ssh-agent client. + * + * PHP version 5 + * + * Here are some examples of how to use this library: + * <code> + * <?php + * include 'vendor/autoload.php'; + * + * $agent = new \phpseclib3\System\SSH\Agent(); + * + * $ssh = new \phpseclib3\Net\SSH2('www.domain.tld'); + * if (!$ssh->login('username', $agent)) { + * exit('Login Failed'); + * } + * + * echo $ssh->exec('pwd'); + * echo $ssh->exec('ls -la'); + * ?> + * </code> + * + * @category System + * @package SSH\Agent + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2014 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + * @internal See http://api.libssh.org/rfc/PROTOCOL.agent + */ + +namespace phpseclib\System\SSH; + +/** + * Pure-PHP ssh-agent client identity factory + * + * requestIdentities() method pumps out \phpseclib3\System\SSH\Agent\Identity objects + * + * @package SSH\Agent + * @author Jim Wigginton <terrafrost@php.net> + * @access public + */ +class Agent extends \phpseclib3\System\SSH\Agent +{ +}
\ No newline at end of file diff --git a/vendor/phpseclib/phpseclib2_compat/src/System/SSH/Agent/Identity.php b/vendor/phpseclib/phpseclib2_compat/src/System/SSH/Agent/Identity.php new file mode 100644 index 000000000..c85f8330f --- /dev/null +++ b/vendor/phpseclib/phpseclib2_compat/src/System/SSH/Agent/Identity.php @@ -0,0 +1,34 @@ +<?php + +/** + * Pure-PHP ssh-agent client. + * + * PHP version 5 + * + * @category System + * @package SSH\Agent + * @author Jim Wigginton <terrafrost@php.net> + * @copyright 2009 Jim Wigginton + * @license http://www.opensource.org/licenses/mit-license.html MIT License + * @link http://phpseclib.sourceforge.net + * @internal See http://api.libssh.org/rfc/PROTOCOL.agent + */ + +namespace phpseclib\System\SSH\Agent; + +/** + * Pure-PHP ssh-agent client identity object + * + * Instantiation should only be performed by \phpseclib3\System\SSH\Agent class. + * This could be thought of as implementing an interface that phpseclib3\Crypt\RSA + * implements. ie. maybe a Net_SSH_Auth_PublicKey interface or something. + * The methods in this interface would be getPublicKey and sign since those are the + * methods phpseclib looks for to perform public key authentication. + * + * @package SSH\Agent + * @author Jim Wigginton <terrafrost@php.net> + * @access internal + */ +class Identity extends \phpseclib3\System\SSH\Agent\Identity +{ +}
\ No newline at end of file |