WMDE
/
LDAPAccountManager
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
LDAPAccountManager/lam/lib/3rdParty/phpseclib/Net/SSH2.php

3687 lines
129 KiB
PHP
Raw Normal View History

added phpseclib
2010-05-14 14:06:17 +00:00
<?php
/**
* Pure-PHP implementation of SSHv2.
*
* PHP versions 4 and 5
*
* Here are some examples of how to use this library:
* <code>
* <?php
* include('Net/SSH2.php');
*
* $ssh = new 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('Crypt/RSA.php');
* include('Net/SSH2.php');
*
* $key = new Crypt_RSA();
* //$key->setPassword('whatever');
* $key->loadKey(file_get_contents('privatekey'));
*
* $ssh = new Net_SSH2('www.domain.tld');
* if (!$ssh->login('username', $key)) {
* exit('Login Failed');
* }
*
new phpseclib
2011-05-19 18:02:11 +00:00
* echo $ssh->read('username@username:~$');
* $ssh->write("ls -la\n");
* echo $ssh->read('username@username:~$');
added phpseclib
2010-05-14 14:06:17 +00:00
* ?>
* </code>
*
new phpseclib
2011-05-19 18:02:11 +00:00
* LICENSE: Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
*
new phpseclib
2011-05-19 18:02:11 +00:00
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
*
new phpseclib
2011-05-19 18:02:11 +00:00
* 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.
added phpseclib
2010-05-14 14:06:17 +00:00
*
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* @category Net
* @package Net_SSH2
* @author Jim Wigginton <terrafrost@php.net>
* @copyright MMVII Jim Wigginton
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @link http://phpseclib.sourceforge.net
added phpseclib
2010-05-14 14:06:17 +00:00
*/
/**#@+
* Execution Bitmap Masks
*
* @see Net_SSH2::bitmap
* @access private
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
define('NET_SSH2_MASK_CONSTRUCTOR', 0x00000001);
define('NET_SSH2_MASK_LOGIN_REQ', 0x00000002);
define('NET_SSH2_MASK_LOGIN', 0x00000004);
define('NET_SSH2_MASK_SHELL', 0x00000008);
define('NET_SSH2_MASK_WINDOW_ADJUST', 0X00000010);
added phpseclib
2010-05-14 14:06:17 +00:00
/**#@-*/
/**#@+
* Channel constants
*
* RFC4254 refers not to client and server channels but rather to sender and recipient channels. we don't refer
* to them in that way because RFC4254 toggles the meaning. the client sends a SSH_MSG_CHANNEL_OPEN message with
* a sender channel and the server sends a SSH_MSG_CHANNEL_OPEN_CONFIRMATION in response, with a sender and a
* recepient channel. at first glance, you might conclude that SSH_MSG_CHANNEL_OPEN_CONFIRMATION's sender channel
* would be the same thing as SSH_MSG_CHANNEL_OPEN's sender channel, but it's not, per this snipet:
* The 'recipient channel' is the channel number given in the original
* open request, and 'sender channel' is the channel number allocated by
* the other side.
*
* @see Net_SSH2::_send_channel_packet()
* @see Net_SSH2::_get_channel_packet()
* @access private
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
define('NET_SSH2_CHANNEL_EXEC', 0); // PuTTy uses 0x100
define('NET_SSH2_CHANNEL_SHELL', 1);
define('NET_SSH2_CHANNEL_SUBSYSTEM', 2);
added phpseclib
2010-05-14 14:06:17 +00:00
/**#@-*/
/**#@+
* @access public
* @see Net_SSH2::getLog()
*/
/**
* Returns the message numbers
*/
define('NET_SSH2_LOG_SIMPLE', 1);
/**
* Returns the message content
*/
define('NET_SSH2_LOG_COMPLEX', 2);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Outputs the content real-time
*/
define('NET_SSH2_LOG_REALTIME', 3);
/**
* Dumps the content real-time to a file
*/
define('NET_SSH2_LOG_REALTIME_FILE', 4);
added phpseclib
2010-05-14 14:06:17 +00:00
/**#@-*/
new phpseclib
2011-05-19 18:02:11 +00:00
/**#@+
* @access public
* @see Net_SSH2::read()
*/
/**
* Returns when a string matching $expect exactly is found
*/
define('NET_SSH2_READ_SIMPLE', 1);
/**
* Returns when a string matching the regular expression $expect is found
*/
define('NET_SSH2_READ_REGEX', 2);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Make sure that the log never gets larger than this
*/
define('NET_SSH2_LOG_MAX_SIZE', 1024 * 1024);
new phpseclib
2011-05-19 18:02:11 +00:00
/**#@-*/
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Pure-PHP implementation of SSHv2.
*
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* @package Net_SSH2
added phpseclib
2010-05-14 14:06:17 +00:00
* @author Jim Wigginton <terrafrost@php.net>
* @version 0.1.0
* @access public
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
class Net_SSH2
{
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* The SSH identifier
*
* @var String
* @access private
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
var $identifier;
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* The Socket Object
*
* @var Object
* @access private
*/
var $fsock;
/**
* Execution Bitmap
*
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* The bits that are set represent functions that have been called already. This is used to determine
added phpseclib
2010-05-14 14:06:17 +00:00
* if a requisite function has been successfully executed. If not, an error should be thrown.
*
* @var Integer
* @access private
*/
var $bitmap = 0;
/**
* Error information
*
* @see Net_SSH2::getErrors()
* @see Net_SSH2::getLastError()
* @var String
* @access private
*/
var $errors = array();
/**
* Server Identifier
*
* @see Net_SSH2::getServerIdentification()
* @var String
* @access private
*/
var $server_identifier = '';
/**
* Key Exchange Algorithms
*
* @see Net_SSH2::getKexAlgorithims()
* @var Array
* @access private
*/
var $kex_algorithms;
/**
* Server Host Key Algorithms
*
* @see Net_SSH2::getServerHostKeyAlgorithms()
* @var Array
* @access private
*/
var $server_host_key_algorithms;
/**
* Encryption Algorithms: Client to Server
*
* @see Net_SSH2::getEncryptionAlgorithmsClient2Server()
* @var Array
* @access private
*/
var $encryption_algorithms_client_to_server;
/**
* Encryption Algorithms: Server to Client
*
* @see Net_SSH2::getEncryptionAlgorithmsServer2Client()
* @var Array
* @access private
*/
var $encryption_algorithms_server_to_client;
/**
* MAC Algorithms: Client to Server
*
* @see Net_SSH2::getMACAlgorithmsClient2Server()
* @var Array
* @access private
*/
var $mac_algorithms_client_to_server;
/**
* MAC Algorithms: Server to Client
*
* @see Net_SSH2::getMACAlgorithmsServer2Client()
* @var Array
* @access private
*/
var $mac_algorithms_server_to_client;
/**
* Compression Algorithms: Client to Server
*
* @see Net_SSH2::getCompressionAlgorithmsClient2Server()
* @var Array
* @access private
*/
var $compression_algorithms_client_to_server;
/**
* Compression Algorithms: Server to Client
*
* @see Net_SSH2::getCompressionAlgorithmsServer2Client()
* @var Array
* @access private
*/
var $compression_algorithms_server_to_client;
/**
* Languages: Server to Client
*
* @see Net_SSH2::getLanguagesServer2Client()
* @var Array
* @access private
*/
var $languages_server_to_client;
/**
* Languages: Client to Server
*
* @see Net_SSH2::getLanguagesClient2Server()
* @var Array
* @access private
*/
var $languages_client_to_server;
/**
* Block Size for Server to Client Encryption
*
* "Note that the length of the concatenation of 'packet_length',
* 'padding_length', 'payload', and 'random padding' MUST be a multiple
* of the cipher block size or 8, whichever is larger. This constraint
* MUST be enforced, even when using stream ciphers."
*
* -- http://tools.ietf.org/html/rfc4253#section-6
*
* @see Net_SSH2::Net_SSH2()
* @see Net_SSH2::_send_binary_packet()
* @var Integer
* @access private
*/
var $encrypt_block_size = 8;
/**
* Block Size for Client to Server Encryption
*
* @see Net_SSH2::Net_SSH2()
* @see Net_SSH2::_get_binary_packet()
* @var Integer
* @access private
*/
var $decrypt_block_size = 8;
/**
* Server to Client Encryption Object
*
* @see Net_SSH2::_get_binary_packet()
* @var Object
* @access private
*/
var $decrypt = false;
/**
* Client to Server Encryption Object
*
* @see Net_SSH2::_send_binary_packet()
* @var Object
* @access private
*/
var $encrypt = false;
/**
* Client to Server HMAC Object
*
* @see Net_SSH2::_send_binary_packet()
* @var Object
* @access private
*/
var $hmac_create = false;
/**
* Server to Client HMAC Object
*
* @see Net_SSH2::_get_binary_packet()
* @var Object
* @access private
*/
var $hmac_check = false;
/**
* Size of server to client HMAC
*
* We need to know how big the HMAC will be for the server to client direction so that we know how many bytes to read.
* For the client to server side, the HMAC object will make the HMAC as long as it needs to be. All we need to do is
* append it.
*
* @see Net_SSH2::_get_binary_packet()
* @var Integer
* @access private
*/
var $hmac_size = false;
/**
* Server Public Host Key
*
* @see Net_SSH2::getServerPublicHostKey()
* @var String
* @access private
*/
var $server_public_host_key;
/**
* Session identifer
*
* "The exchange hash H from the first key exchange is additionally
* used as the session identifier, which is a unique identifier for
* this connection."
*
* -- http://tools.ietf.org/html/rfc4253#section-7.2
*
* @see Net_SSH2::_key_exchange()
* @var String
* @access private
*/
var $session_id = false;
new phpseclib
2011-05-19 18:02:11 +00:00
/**
* Exchange hash
*
* The current exchange hash
*
* @see Net_SSH2::_key_exchange()
* @var String
* @access private
*/
var $exchange_hash = false;
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Message Numbers
*
* @see Net_SSH2::Net_SSH2()
* @var Array
* @access private
*/
var $message_numbers = array();
/**
* Disconnection Message 'reason codes' defined in RFC4253
*
* @see Net_SSH2::Net_SSH2()
* @var Array
* @access private
*/
var $disconnect_reasons = array();
/**
* SSH_MSG_CHANNEL_OPEN_FAILURE 'reason codes', defined in RFC4254
*
* @see Net_SSH2::Net_SSH2()
* @var Array
* @access private
*/
var $channel_open_failure_reasons = array();
/**
* Terminal Modes
*
* @link http://tools.ietf.org/html/rfc4254#section-8
* @see Net_SSH2::Net_SSH2()
* @var Array
* @access private
*/
var $terminal_modes = array();
/**
* SSH_MSG_CHANNEL_EXTENDED_DATA's data_type_codes
*
* @link http://tools.ietf.org/html/rfc4254#section-5.2
* @see Net_SSH2::Net_SSH2()
* @var Array
* @access private
*/
var $channel_extended_data_type_codes = array();
/**
* Send Sequence Number
*
* See 'Section 6.4. Data Integrity' of rfc4253 for more info.
*
* @see Net_SSH2::_send_binary_packet()
* @var Integer
* @access private
*/
var $send_seq_no = 0;
/**
* Get Sequence Number
*
* See 'Section 6.4. Data Integrity' of rfc4253 for more info.
*
* @see Net_SSH2::_get_binary_packet()
* @var Integer
* @access private
*/
var $get_seq_no = 0;
/**
* Server Channels
*
* Maps client channels to server channels
*
* @see Net_SSH2::_get_channel_packet()
* @see Net_SSH2::exec()
* @var Array
* @access private
*/
var $server_channels = array();
/**
* Channel Buffers
*
* If a client requests a packet from one channel but receives two packets from another those packets should
* be placed in a buffer
*
* @see Net_SSH2::_get_channel_packet()
* @see Net_SSH2::exec()
* @var Array
* @access private
*/
var $channel_buffers = array();
/**
* Channel Status
*
* Contains the type of the last sent message
*
* @see Net_SSH2::_get_channel_packet()
* @var Array
* @access private
*/
var $channel_status = array();
/**
* Packet Size
*
* Maximum packet size indexed by channel
*
* @see Net_SSH2::_send_channel_packet()
* @var Array
* @access private
*/
var $packet_size_client_to_server = array();
/**
* Message Number Log
*
* @see Net_SSH2::getLog()
* @var Array
* @access private
*/
var $message_number_log = array();
/**
* Message Log
*
* @see Net_SSH2::getLog()
* @var Array
* @access private
*/
var $message_log = array();
/**
* The Window Size
*
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* Bytes the other party can send before it must wait for the window to be adjusted (0x7FFFFFFF = 2GB)
added phpseclib
2010-05-14 14:06:17 +00:00
*
* @var Integer
* @see Net_SSH2::_send_channel_packet()
* @see Net_SSH2::exec()
* @access private
*/
var $window_size = 0x7FFFFFFF;
/**
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* Window size, server to client
added phpseclib
2010-05-14 14:06:17 +00:00
*
* Window size indexed by channel
*
* @see Net_SSH2::_send_channel_packet()
* @var Array
* @access private
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
var $window_size_server_to_client = array();
/**
* Window size, client to server
*
* Window size indexed by channel
*
* @see Net_SSH2::_get_channel_packet()
* @var Array
* @access private
*/
added phpseclib
2010-05-14 14:06:17 +00:00
var $window_size_client_to_server = array();
/**
* Server signature
*
* Verified against $this->session_id
*
* @see Net_SSH2::getServerPublicHostKey()
* @var String
* @access private
*/
var $signature = '';
/**
* Server signature format
*
* ssh-rsa or ssh-dss.
*
* @see Net_SSH2::getServerPublicHostKey()
* @var String
* @access private
*/
var $signature_format = '';
new phpseclib
2011-05-19 18:02:11 +00:00
/**
* Interactive Buffer
*
* @see Net_SSH2::read()
* @var Array
* @access private
*/
var $interactiveBuffer = '';
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Current log size
*
* Should never exceed NET_SSH2_LOG_MAX_SIZE
*
* @see Net_SSH2::_send_binary_packet()
* @see Net_SSH2::_get_binary_packet()
* @var Integer
* @access private
*/
var $log_size;
/**
* Timeout
*
* @see Net_SSH2::setTimeout()
* @access private
*/
var $timeout;
/**
* Current Timeout
*
* @see Net_SSH2::_get_channel_packet()
* @access private
*/
var $curTimeout;
/**
* Real-time log file pointer
*
* @see Net_SSH2::_append_log()
* @var Resource
* @access private
*/
var $realtime_log_file;
/**
* Real-time log file size
*
* @see Net_SSH2::_append_log()
* @var Integer
* @access private
*/
var $realtime_log_size;
/**
* Has the signature been validated?
*
* @see Net_SSH2::getServerPublicHostKey()
* @var Boolean
* @access private
*/
var $signature_validated = false;
/**
* Real-time log file wrap boolean
*
* @see Net_SSH2::_append_log()
* @access private
*/
var $realtime_log_wrap;
/**
* Flag to suppress stderr from output
*
* @see Net_SSH2::enableQuietMode()
* @access private
*/
var $quiet_mode = false;
/**
* Time of first network activity
*
* @access private
*/
var $last_packet;
/**
* Exit status returned from ssh if any
*
* @var Integer
* @access private
*/
var $exit_status;
/**
* Flag to request a PTY when using exec()
*
* @see Net_SSH2::enablePTY()
* @access private
*/
var $request_pty = false;
/**
* Flag set while exec() is running when using enablePTY()
*
* @access private
*/
var $in_request_pty_exec = false;
/**
* Flag set after startSubsystem() is called
*
* @access private
*/
var $in_subsystem;
/**
* Contents of stdError
*
* @access private
*/
var $stdErrorLog;
/**
* The Last Interactive Response
*
* @see Net_SSH2::_keyboard_interactive_process()
* @access private
*/
var $last_interactive_response = '';
/**
* Keyboard Interactive Request / Responses
*
* @see Net_SSH2::_keyboard_interactive_process()
* @access private
*/
var $keyboard_requests_responses = array();
/**
* Banner Message
*
* Quoting from the RFC, "in some jurisdictions, sending a warning message before
* authentication may be relevant for getting legal protection."
*
* @see Net_SSH2::_filter()
* @see Net_SSH2::getBannerMessage()
* @access private
*/
var $banner_message = '';
/**
* Did read() timeout or return normally?
*
* @see Net_SSH2::isTimeout
* @access private
*/
var $is_timeout = false;
/**
* Log Boundary
*
* @see Net_SSH2::_format_log
* @access private
*/
var $log_boundary = ':';
/**
* Log Long Width
*
* @see Net_SSH2::_format_log
* @access private
*/
var $log_long_width = 65;
/**
* Log Short Width
*
* @see Net_SSH2::_format_log
* @access private
*/
var $log_short_width = 16;
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Default Constructor.
*
* Connects to an SSHv2 server
*
* @param String $host
* @param optional Integer $port
* @param optional Integer $timeout
* @return Net_SSH2
* @access public
*/
function Net_SSH2($host, $port = 22, $timeout = 10)
{
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// Include Math_BigInteger
// Used to do Diffie-Hellman key exchange and DSA/RSA signature verification.
if (!class_exists('Math_BigInteger')) {
include_once 'Math/BigInteger.php';
}
if (!function_exists('crypt_random_string')) {
include_once 'Crypt/Random.php';
}
if (!class_exists('Crypt_Hash')) {
include_once 'Crypt/Hash.php';
}
$this->last_packet = strtok(microtime(), ' ') + strtok(''); // == microtime(true) in PHP5
added phpseclib
2010-05-14 14:06:17 +00:00
$this->message_numbers = array(
1 => 'NET_SSH2_MSG_DISCONNECT',
2 => 'NET_SSH2_MSG_IGNORE',
3 => 'NET_SSH2_MSG_UNIMPLEMENTED',
4 => 'NET_SSH2_MSG_DEBUG',
5 => 'NET_SSH2_MSG_SERVICE_REQUEST',
6 => 'NET_SSH2_MSG_SERVICE_ACCEPT',
20 => 'NET_SSH2_MSG_KEXINIT',
21 => 'NET_SSH2_MSG_NEWKEYS',
30 => 'NET_SSH2_MSG_KEXDH_INIT',
31 => 'NET_SSH2_MSG_KEXDH_REPLY',
50 => 'NET_SSH2_MSG_USERAUTH_REQUEST',
51 => 'NET_SSH2_MSG_USERAUTH_FAILURE',
52 => 'NET_SSH2_MSG_USERAUTH_SUCCESS',
53 => 'NET_SSH2_MSG_USERAUTH_BANNER',
80 => 'NET_SSH2_MSG_GLOBAL_REQUEST',
81 => 'NET_SSH2_MSG_REQUEST_SUCCESS',
82 => 'NET_SSH2_MSG_REQUEST_FAILURE',
90 => 'NET_SSH2_MSG_CHANNEL_OPEN',
91 => 'NET_SSH2_MSG_CHANNEL_OPEN_CONFIRMATION',
92 => 'NET_SSH2_MSG_CHANNEL_OPEN_FAILURE',
93 => 'NET_SSH2_MSG_CHANNEL_WINDOW_ADJUST',
94 => 'NET_SSH2_MSG_CHANNEL_DATA',
95 => 'NET_SSH2_MSG_CHANNEL_EXTENDED_DATA',
96 => 'NET_SSH2_MSG_CHANNEL_EOF',
97 => 'NET_SSH2_MSG_CHANNEL_CLOSE',
98 => 'NET_SSH2_MSG_CHANNEL_REQUEST',
99 => 'NET_SSH2_MSG_CHANNEL_SUCCESS',
100 => 'NET_SSH2_MSG_CHANNEL_FAILURE'
);
$this->disconnect_reasons = array(
1 => 'NET_SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT',
2 => 'NET_SSH2_DISCONNECT_PROTOCOL_ERROR',
3 => 'NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED',
4 => 'NET_SSH2_DISCONNECT_RESERVED',
5 => 'NET_SSH2_DISCONNECT_MAC_ERROR',
6 => 'NET_SSH2_DISCONNECT_COMPRESSION_ERROR',
7 => 'NET_SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE',
8 => 'NET_SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED',
9 => 'NET_SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE',
10 => 'NET_SSH2_DISCONNECT_CONNECTION_LOST',
11 => 'NET_SSH2_DISCONNECT_BY_APPLICATION',
12 => 'NET_SSH2_DISCONNECT_TOO_MANY_CONNECTIONS',
13 => 'NET_SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER',
14 => 'NET_SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE',
15 => 'NET_SSH2_DISCONNECT_ILLEGAL_USER_NAME'
);
$this->channel_open_failure_reasons = array(
1 => 'NET_SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED'
);
$this->terminal_modes = array(
0 => 'NET_SSH2_TTY_OP_END'
);
$this->channel_extended_data_type_codes = array(
1 => 'NET_SSH2_EXTENDED_DATA_STDERR'
);
$this->_define_array(
$this->message_numbers,
$this->disconnect_reasons,
$this->channel_open_failure_reasons,
$this->terminal_modes,
$this->channel_extended_data_type_codes,
array(60 => 'NET_SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ'),
new phpseclib
2011-05-19 18:02:11 +00:00
array(60 => 'NET_SSH2_MSG_USERAUTH_PK_OK'),
array(60 => 'NET_SSH2_MSG_USERAUTH_INFO_REQUEST',
61 => 'NET_SSH2_MSG_USERAUTH_INFO_RESPONSE')
added phpseclib
2010-05-14 14:06:17 +00:00
);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$start = strtok(microtime(), ' ') + strtok(''); // http://php.net/microtime#61838
added phpseclib
2010-05-14 14:06:17 +00:00
$this->fsock = @fsockopen($host, $port, $errno, $errstr, $timeout);
if (!$this->fsock) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error(rtrim("Cannot connect to $host. Error $errno. $errstr"));
return;
}
$elapsed = strtok(microtime(), ' ') + strtok('') - $start;
$timeout-= $elapsed;
if ($timeout <= 0) {
user_error(rtrim("Cannot connect to $host. Timeout error"));
return;
}
$read = array($this->fsock);
$write = $except = null;
$sec = floor($timeout);
$usec = 1000000 * ($timeout - $sec);
// on windows this returns a "Warning: Invalid CRT parameters detected" error
// the !count() is done as a workaround for <https://bugs.php.net/42682>
if (!@stream_select($read, $write, $except, $sec, $usec) && !count($read)) {
user_error(rtrim("Cannot connect to $host. Banner timeout"));
added phpseclib
2010-05-14 14:06:17 +00:00
return;
}
/* According to the SSH2 specs,
"The server MAY send other lines of data before sending the version
string. Each line SHOULD be terminated by a Carriage Return and Line
Feed. Such lines MUST NOT begin with "SSH-", and SHOULD be encoded
in ISO-10646 UTF-8 [RFC3629] (language is not specified). Clients
MUST be able to process such lines." */
$temp = '';
$extra = '';
while (!feof($this->fsock) && !preg_match('#^SSH-(\d\.\d+)#', $temp, $matches)) {
if (substr($temp, -2) == "\r\n") {
$extra.= $temp;
$temp = '';
}
$temp.= fgets($this->fsock, 255);
}
new phpseclib
2011-05-19 18:02:11 +00:00
if (feof($this->fsock)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
new phpseclib
2011-05-19 18:02:11 +00:00
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->identifier = $this->_generate_identifier();
added phpseclib
2010-05-14 14:06:17 +00:00
if (defined('NET_SSH2_LOGGING')) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->_append_log('<-', $extra . $temp);
$this->_append_log('->', $this->identifier . "\r\n");
added phpseclib
2010-05-14 14:06:17 +00:00
}
$this->server_identifier = trim($temp, "\r\n");
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (strlen($extra)) {
added phpseclib
2010-05-14 14:06:17 +00:00
$this->errors[] = utf8_decode($extra);
}
if ($matches[1] != '1.99' && $matches[1] != '2.0') {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error("Cannot connect to SSH $matches[1] servers");
added phpseclib
2010-05-14 14:06:17 +00:00
return;
}
fputs($this->fsock, $this->identifier . "\r\n");
$response = $this->_get_binary_packet();
if ($response === false) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
added phpseclib
2010-05-14 14:06:17 +00:00
return;
}
if (ord($response[0]) != NET_SSH2_MSG_KEXINIT) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Expected SSH_MSG_KEXINIT');
added phpseclib
2010-05-14 14:06:17 +00:00
return;
}
if (!$this->_key_exchange($response)) {
return;
}
$this->bitmap = NET_SSH2_MASK_CONSTRUCTOR;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Generates the SSH identifier
*
* You should overwrite this method in your own class if you want to use another identifier
*
* @access protected
* @return String
*/
function _generate_identifier()
{
$identifier = 'SSH-2.0-phpseclib_0.3';
$ext = array();
if (extension_loaded('mcrypt')) {
$ext[] = 'mcrypt';
}
if (extension_loaded('gmp')) {
$ext[] = 'gmp';
} elseif (extension_loaded('bcmath')) {
$ext[] = 'bcmath';
}
if (!empty($ext)) {
$identifier .= ' (' . implode(', ', $ext) . ')';
}
return $identifier;
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Key Exchange
*
* @param String $kexinit_payload_server
* @access private
*/
function _key_exchange($kexinit_payload_server)
{
static $kex_algorithms = array(
'diffie-hellman-group1-sha1', // REQUIRED
'diffie-hellman-group14-sha1' // REQUIRED
);
static $server_host_key_algorithms = array(
'ssh-rsa', // RECOMMENDED sign Raw RSA Key
'ssh-dss' // REQUIRED sign Raw DSS Key
);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
static $encryption_algorithms = false;
if ($encryption_algorithms === false) {
$encryption_algorithms = array(
// from <http://tools.ietf.org/html/rfc4345#section-4>:
'arcfour256',
'arcfour128',
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
'arcfour', // OPTIONAL the ARCFOUR stream cipher with a 128-bit key
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// CTR modes from <http://tools.ietf.org/html/rfc4344#section-4>:
'aes128-ctr', // RECOMMENDED AES (Rijndael) in SDCTR mode, with 128-bit key
'aes192-ctr', // RECOMMENDED AES with 192-bit key
'aes256-ctr', // RECOMMENDED AES with 256-bit key
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
'twofish128-ctr', // OPTIONAL Twofish in SDCTR mode, with 128-bit key
'twofish192-ctr', // OPTIONAL Twofish with 192-bit key
'twofish256-ctr', // OPTIONAL Twofish with 256-bit key
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
'aes128-cbc', // RECOMMENDED AES with a 128-bit key
'aes192-cbc', // OPTIONAL AES with a 192-bit key
'aes256-cbc', // OPTIONAL AES in CBC mode, with a 256-bit key
'twofish128-cbc', // OPTIONAL Twofish with a 128-bit key
'twofish192-cbc', // OPTIONAL Twofish with a 192-bit key
'twofish256-cbc',
'twofish-cbc', // OPTIONAL alias for "twofish256-cbc"
// (this is being retained for historical reasons)
'blowfish-ctr', // OPTIONAL Blowfish in SDCTR mode
'blowfish-cbc', // OPTIONAL Blowfish in CBC mode
'3des-ctr', // RECOMMENDED Three-key 3DES in SDCTR mode
'3des-cbc', // REQUIRED three-key 3DES in CBC mode
'none' // OPTIONAL no encryption; NOT RECOMMENDED
);
if (!$this->_is_includable('Crypt/RC4.php')) {
$encryption_algorithms = array_diff(
$encryption_algorithms,
array('arcfour256', 'arcfour128', 'arcfour')
);
}
if (!$this->_is_includable('Crypt/Rijndael.php')) {
$encryption_algorithms = array_diff(
$encryption_algorithms,
array('aes128-ctr', 'aes192-ctr', 'aes256-ctr', 'aes128-cbc', 'aes192-cbc', 'aes256-cbc')
);
}
if (!$this->_is_includable('Crypt/Twofish.php')) {
$encryption_algorithms = array_diff(
$encryption_algorithms,
array('twofish128-ctr', 'twofish192-ctr', 'twofish256-ctr', 'twofish128-cbc', 'twofish192-cbc', 'twofish256-cbc', 'twofish-cbc')
);
}
if (!$this->_is_includable('Crypt/Blowfish.php')) {
$encryption_algorithms = array_diff(
$encryption_algorithms,
array('blowfish-ctr', 'blowfish-cbc')
);
}
if (!$this->_is_includable('Crypt/TripleDES.php')) {
$encryption_algorithms = array_diff(
$encryption_algorithms,
array('3des-ctr', '3des-cbc')
);
}
$encryption_algorithms = array_values($encryption_algorithms);
}
added phpseclib
2010-05-14 14:06:17 +00:00
static $mac_algorithms = array(
'hmac-sha1-96', // RECOMMENDED first 96 bits of HMAC-SHA1 (digest length = 12, key length = 20)
'hmac-sha1', // REQUIRED HMAC-SHA1 (digest length = key length = 20)
'hmac-md5-96', // OPTIONAL first 96 bits of HMAC-MD5 (digest length = 12, key length = 16)
'hmac-md5', // OPTIONAL HMAC-MD5 (digest length = key length = 16)
'none' // OPTIONAL no MAC; NOT RECOMMENDED
);
static $compression_algorithms = array(
'none' // REQUIRED no compression
//'zlib' // OPTIONAL ZLIB (LZ77) compression
);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// some SSH servers have buggy implementations of some of the above algorithms
switch ($this->server_identifier) {
case 'SSH-2.0-SSHD':
$mac_algorithms = array_values(array_diff(
$mac_algorithms,
array('hmac-sha1-96', 'hmac-md5-96')
));
}
added phpseclib
2010-05-14 14:06:17 +00:00
static $str_kex_algorithms, $str_server_host_key_algorithms,
$encryption_algorithms_server_to_client, $mac_algorithms_server_to_client, $compression_algorithms_server_to_client,
$encryption_algorithms_client_to_server, $mac_algorithms_client_to_server, $compression_algorithms_client_to_server;
if (empty($str_kex_algorithms)) {
$str_kex_algorithms = implode(',', $kex_algorithms);
$str_server_host_key_algorithms = implode(',', $server_host_key_algorithms);
$encryption_algorithms_server_to_client = $encryption_algorithms_client_to_server = implode(',', $encryption_algorithms);
$mac_algorithms_server_to_client = $mac_algorithms_client_to_server = implode(',', $mac_algorithms);
$compression_algorithms_server_to_client = $compression_algorithms_client_to_server = implode(',', $compression_algorithms);
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$client_cookie = crypt_random_string(16);
added phpseclib
2010-05-14 14:06:17 +00:00
$response = $kexinit_payload_server;
$this->_string_shift($response, 1); // skip past the message number (it should be SSH_MSG_KEXINIT)
$server_cookie = $this->_string_shift($response, 16);
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->kex_algorithms = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->server_host_key_algorithms = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->encryption_algorithms_client_to_server = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->encryption_algorithms_server_to_client = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->mac_algorithms_client_to_server = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->mac_algorithms_server_to_client = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->compression_algorithms_client_to_server = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->compression_algorithms_server_to_client = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->languages_client_to_server = explode(',', $this->_string_shift($response, $temp['length']));
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->languages_server_to_client = explode(',', $this->_string_shift($response, $temp['length']));
extract(unpack('Cfirst_kex_packet_follows', $this->_string_shift($response, 1)));
$first_kex_packet_follows = $first_kex_packet_follows != 0;
// the sending of SSH2_MSG_KEXINIT could go in one of two places. this is the second place.
$kexinit_payload_client = pack('Ca*Na*Na*Na*Na*Na*Na*Na*Na*Na*Na*CN',
NET_SSH2_MSG_KEXINIT, $client_cookie, strlen($str_kex_algorithms), $str_kex_algorithms,
strlen($str_server_host_key_algorithms), $str_server_host_key_algorithms, strlen($encryption_algorithms_client_to_server),
$encryption_algorithms_client_to_server, strlen($encryption_algorithms_server_to_client), $encryption_algorithms_server_to_client,
strlen($mac_algorithms_client_to_server), $mac_algorithms_client_to_server, strlen($mac_algorithms_server_to_client),
$mac_algorithms_server_to_client, strlen($compression_algorithms_client_to_server), $compression_algorithms_client_to_server,
strlen($compression_algorithms_server_to_client), $compression_algorithms_server_to_client, 0, '', 0, '',
0, 0
);
if (!$this->_send_binary_packet($kexinit_payload_client)) {
return false;
}
// here ends the second place.
// we need to decide upon the symmetric encryption algorithms before we do the diffie-hellman key exchange
for ($i = 0; $i < count($encryption_algorithms) && !in_array($encryption_algorithms[$i], $this->encryption_algorithms_server_to_client); $i++);
if ($i == count($encryption_algorithms)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('No compatible server to client encryption algorithms found');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
// we don't initialize any crypto-objects, yet - we do that, later. for now, we need the lengths to make the
// diffie-hellman key exchange as fast as possible
$decrypt = $encryption_algorithms[$i];
switch ($decrypt) {
case '3des-cbc':
case '3des-ctr':
$decryptKeyLength = 24; // eg. 192 / 8
break;
case 'aes256-cbc':
case 'aes256-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case 'twofish-cbc':
case 'twofish256-cbc':
case 'twofish256-ctr':
added phpseclib
2010-05-14 14:06:17 +00:00
$decryptKeyLength = 32; // eg. 256 / 8
break;
case 'aes192-cbc':
case 'aes192-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case 'twofish192-cbc':
case 'twofish192-ctr':
added phpseclib
2010-05-14 14:06:17 +00:00
$decryptKeyLength = 24; // eg. 192 / 8
break;
case 'aes128-cbc':
case 'aes128-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case 'twofish128-cbc':
case 'twofish128-ctr':
case 'blowfish-cbc':
case 'blowfish-ctr':
added phpseclib
2010-05-14 14:06:17 +00:00
$decryptKeyLength = 16; // eg. 128 / 8
break;
case 'arcfour':
case 'arcfour128':
$decryptKeyLength = 16; // eg. 128 / 8
break;
case 'arcfour256':
$decryptKeyLength = 32; // eg. 128 / 8
break;
case 'none';
$decryptKeyLength = 0;
}
for ($i = 0; $i < count($encryption_algorithms) && !in_array($encryption_algorithms[$i], $this->encryption_algorithms_client_to_server); $i++);
if ($i == count($encryption_algorithms)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('No compatible client to server encryption algorithms found');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
$encrypt = $encryption_algorithms[$i];
switch ($encrypt) {
case '3des-cbc':
case '3des-ctr':
$encryptKeyLength = 24;
break;
case 'aes256-cbc':
case 'aes256-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case 'twofish-cbc':
case 'twofish256-cbc':
case 'twofish256-ctr':
added phpseclib
2010-05-14 14:06:17 +00:00
$encryptKeyLength = 32;
break;
case 'aes192-cbc':
case 'aes192-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case 'twofish192-cbc':
case 'twofish192-ctr':
added phpseclib
2010-05-14 14:06:17 +00:00
$encryptKeyLength = 24;
break;
case 'aes128-cbc':
case 'aes128-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case 'twofish128-cbc':
case 'twofish128-ctr':
case 'blowfish-cbc':
case 'blowfish-ctr':
added phpseclib
2010-05-14 14:06:17 +00:00
$encryptKeyLength = 16;
break;
case 'arcfour':
case 'arcfour128':
$encryptKeyLength = 16;
break;
case 'arcfour256':
$encryptKeyLength = 32;
break;
case 'none';
$encryptKeyLength = 0;
}
$keyLength = $decryptKeyLength > $encryptKeyLength ? $decryptKeyLength : $encryptKeyLength;
// through diffie-hellman key exchange a symmetric key is obtained
for ($i = 0; $i < count($kex_algorithms) && !in_array($kex_algorithms[$i], $this->kex_algorithms); $i++);
if ($i == count($kex_algorithms)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('No compatible key exchange algorithms found');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
switch ($kex_algorithms[$i]) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// see http://tools.ietf.org/html/rfc2409#section-6.2 and
added phpseclib
2010-05-14 14:06:17 +00:00
// http://tools.ietf.org/html/rfc2412, appendex E
case 'diffie-hellman-group1-sha1':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$prime = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' .
'020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437' .
'4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' .
'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF';
added phpseclib
2010-05-14 14:06:17 +00:00
break;
// see http://tools.ietf.org/html/rfc3526#section-3
case 'diffie-hellman-group14-sha1':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$prime = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' .
'020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437' .
'4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' .
'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF05' .
'98DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB' .
'9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B' .
'E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718' .
'3995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF';
break;
}
// For both diffie-hellman-group1-sha1 and diffie-hellman-group14-sha1
// the generator field element is 2 (decimal) and the hash function is sha1.
$g = new Math_BigInteger(2);
$prime = new Math_BigInteger($prime, 16);
$kexHash = new Crypt_Hash('sha1');
added phpseclib
2010-05-14 14:06:17 +00:00
//$q = $p->bitwise_rightShift(1);
/* To increase the speed of the key exchange, both client and server may
reduce the size of their private exponents. It should be at least
twice as long as the key material that is generated from the shared
secret. For more details, see the paper by van Oorschot and Wiener
[VAN-OORSCHOT].
-- http://tools.ietf.org/html/rfc4419#section-6.2 */
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$one = new Math_BigInteger(1);
$keyLength = min($keyLength, $kexHash->getLength());
$max = $one->bitwise_leftShift(16 * $keyLength); // 2 * 8 * $keyLength
$max = $max->subtract($one);
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$x = $one->random($one, $max);
$e = $g->modPow($x, $prime);
added phpseclib
2010-05-14 14:06:17 +00:00
$eBytes = $e->toBytes(true);
$data = pack('CNa*', NET_SSH2_MSG_KEXDH_INIT, strlen($eBytes), $eBytes);
if (!$this->_send_binary_packet($data)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
$response = $this->_get_binary_packet();
if ($response === false) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
extract(unpack('Ctype', $this->_string_shift($response, 1)));
if ($type != NET_SSH2_MSG_KEXDH_REPLY) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Expected SSH_MSG_KEXDH_REPLY');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->server_public_host_key = $server_public_host_key = $this->_string_shift($response, $temp['length']);
$temp = unpack('Nlength', $this->_string_shift($server_public_host_key, 4));
$public_key_format = $this->_string_shift($server_public_host_key, $temp['length']);
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$fBytes = $this->_string_shift($response, $temp['length']);
$f = new Math_BigInteger($fBytes, -256);
$temp = unpack('Nlength', $this->_string_shift($response, 4));
$this->signature = $this->_string_shift($response, $temp['length']);
$temp = unpack('Nlength', $this->_string_shift($this->signature, 4));
$this->signature_format = $this->_string_shift($this->signature, $temp['length']);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key = $f->modPow($x, $prime);
added phpseclib
2010-05-14 14:06:17 +00:00
$keyBytes = $key->toBytes(true);
new phpseclib
2011-05-19 18:02:11 +00:00
$this->exchange_hash = pack('Na*Na*Na*Na*Na*Na*Na*Na*',
strlen($this->identifier), $this->identifier, strlen($this->server_identifier), $this->server_identifier,
strlen($kexinit_payload_client), $kexinit_payload_client, strlen($kexinit_payload_server),
$kexinit_payload_server, strlen($this->server_public_host_key), $this->server_public_host_key, strlen($eBytes),
$eBytes, strlen($fBytes), $fBytes, strlen($keyBytes), $keyBytes
);
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->exchange_hash = $kexHash->hash($this->exchange_hash);
added phpseclib
2010-05-14 14:06:17 +00:00
new phpseclib
2011-05-19 18:02:11 +00:00
if ($this->session_id === false) {
$this->session_id = $this->exchange_hash;
added phpseclib
2010-05-14 14:06:17 +00:00
}
for ($i = 0; $i < count($server_host_key_algorithms) && !in_array($server_host_key_algorithms[$i], $this->server_host_key_algorithms); $i++);
if ($i == count($server_host_key_algorithms)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('No compatible server host key algorithms found');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
if ($public_key_format != $server_host_key_algorithms[$i] || $this->signature_format != $server_host_key_algorithms[$i]) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Server Host Key Algorithm Mismatch');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
$packet = pack('C',
NET_SSH2_MSG_NEWKEYS
);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$response = $this->_get_binary_packet();
if ($response === false) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
extract(unpack('Ctype', $this->_string_shift($response, 1)));
if ($type != NET_SSH2_MSG_NEWKEYS) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Expected SSH_MSG_NEWKEYS');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
switch ($encrypt) {
case '3des-cbc':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_TripleDES')) {
include_once 'Crypt/TripleDES.php';
}
added phpseclib
2010-05-14 14:06:17 +00:00
$this->encrypt = new Crypt_TripleDES();
// $this->encrypt_block_size = 64 / 8 == the default
break;
case '3des-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_TripleDES')) {
include_once 'Crypt/TripleDES.php';
}
added phpseclib
2010-05-14 14:06:17 +00:00
$this->encrypt = new Crypt_TripleDES(CRYPT_DES_MODE_CTR);
// $this->encrypt_block_size = 64 / 8 == the default
break;
case 'aes256-cbc':
case 'aes192-cbc':
case 'aes128-cbc':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_Rijndael')) {
include_once 'Crypt/Rijndael.php';
}
$this->encrypt = new Crypt_Rijndael();
added phpseclib
2010-05-14 14:06:17 +00:00
$this->encrypt_block_size = 16; // eg. 128 / 8
break;
case 'aes256-ctr':
case 'aes192-ctr':
case 'aes128-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_Rijndael')) {
include_once 'Crypt/Rijndael.php';
}
$this->encrypt = new Crypt_Rijndael(CRYPT_RIJNDAEL_MODE_CTR);
added phpseclib
2010-05-14 14:06:17 +00:00
$this->encrypt_block_size = 16; // eg. 128 / 8
break;
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case 'blowfish-cbc':
if (!class_exists('Crypt_Blowfish')) {
include_once 'Crypt/Blowfish.php';
}
$this->encrypt = new Crypt_Blowfish();
$this->encrypt_block_size = 8;
break;
case 'blowfish-ctr':
if (!class_exists('Crypt_Blowfish')) {
include_once 'Crypt/Blowfish.php';
}
$this->encrypt = new Crypt_Blowfish(CRYPT_BLOWFISH_MODE_CTR);
$this->encrypt_block_size = 8;
break;
case 'twofish128-cbc':
case 'twofish192-cbc':
case 'twofish256-cbc':
case 'twofish-cbc':
if (!class_exists('Crypt_Twofish')) {
include_once 'Crypt/Twofish.php';
}
$this->encrypt = new Crypt_Twofish();
$this->encrypt_block_size = 16;
break;
case 'twofish128-ctr':
case 'twofish192-ctr':
case 'twofish256-ctr':
if (!class_exists('Crypt_Twofish')) {
include_once 'Crypt/Twofish.php';
}
$this->encrypt = new Crypt_Twofish(CRYPT_TWOFISH_MODE_CTR);
$this->encrypt_block_size = 16;
break;
added phpseclib
2010-05-14 14:06:17 +00:00
case 'arcfour':
case 'arcfour128':
case 'arcfour256':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_RC4')) {
include_once 'Crypt/RC4.php';
}
added phpseclib
2010-05-14 14:06:17 +00:00
$this->encrypt = new Crypt_RC4();
break;
case 'none';
//$this->encrypt = new Crypt_Null();
}
switch ($decrypt) {
case '3des-cbc':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_TripleDES')) {
include_once 'Crypt/TripleDES.php';
}
added phpseclib
2010-05-14 14:06:17 +00:00
$this->decrypt = new Crypt_TripleDES();
break;
case '3des-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_TripleDES')) {
include_once 'Crypt/TripleDES.php';
}
added phpseclib
2010-05-14 14:06:17 +00:00
$this->decrypt = new Crypt_TripleDES(CRYPT_DES_MODE_CTR);
break;
case 'aes256-cbc':
case 'aes192-cbc':
case 'aes128-cbc':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_Rijndael')) {
include_once 'Crypt/Rijndael.php';
}
$this->decrypt = new Crypt_Rijndael();
added phpseclib
2010-05-14 14:06:17 +00:00
$this->decrypt_block_size = 16;
break;
case 'aes256-ctr':
case 'aes192-ctr':
case 'aes128-ctr':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_Rijndael')) {
include_once 'Crypt/Rijndael.php';
}
$this->decrypt = new Crypt_Rijndael(CRYPT_RIJNDAEL_MODE_CTR);
$this->decrypt_block_size = 16;
break;
case 'blowfish-cbc':
if (!class_exists('Crypt_Blowfish')) {
include_once 'Crypt/Blowfish.php';
}
$this->decrypt = new Crypt_Blowfish();
$this->decrypt_block_size = 8;
break;
case 'blowfish-ctr':
if (!class_exists('Crypt_Blowfish')) {
include_once 'Crypt/Blowfish.php';
}
$this->decrypt = new Crypt_Blowfish(CRYPT_BLOWFISH_MODE_CTR);
$this->decrypt_block_size = 8;
break;
case 'twofish128-cbc':
case 'twofish192-cbc':
case 'twofish256-cbc':
case 'twofish-cbc':
if (!class_exists('Crypt_Twofish')) {
include_once 'Crypt/Twofish.php';
}
$this->decrypt = new Crypt_Twofish();
$this->decrypt_block_size = 16;
break;
case 'twofish128-ctr':
case 'twofish192-ctr':
case 'twofish256-ctr':
if (!class_exists('Crypt_Twofish')) {
include_once 'Crypt/Twofish.php';
}
$this->decrypt = new Crypt_Twofish(CRYPT_TWOFISH_MODE_CTR);
added phpseclib
2010-05-14 14:06:17 +00:00
$this->decrypt_block_size = 16;
break;
case 'arcfour':
case 'arcfour128':
case 'arcfour256':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!class_exists('Crypt_RC4')) {
include_once 'Crypt/RC4.php';
}
added phpseclib
2010-05-14 14:06:17 +00:00
$this->decrypt = new Crypt_RC4();
break;
case 'none';
//$this->decrypt = new Crypt_Null();
}
$keyBytes = pack('Na*', strlen($keyBytes), $keyBytes);
if ($this->encrypt) {
$this->encrypt->enableContinuousBuffer();
$this->encrypt->disablePadding();
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$iv = $kexHash->hash($keyBytes . $this->exchange_hash . 'A' . $this->session_id);
added phpseclib
2010-05-14 14:06:17 +00:00
while ($this->encrypt_block_size > strlen($iv)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$iv.= $kexHash->hash($keyBytes . $this->exchange_hash . $iv);
added phpseclib
2010-05-14 14:06:17 +00:00
}
$this->encrypt->setIV(substr($iv, 0, $this->encrypt_block_size));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key = $kexHash->hash($keyBytes . $this->exchange_hash . 'C' . $this->session_id);
added phpseclib
2010-05-14 14:06:17 +00:00
while ($encryptKeyLength > strlen($key)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key.= $kexHash->hash($keyBytes . $this->exchange_hash . $key);
added phpseclib
2010-05-14 14:06:17 +00:00
}
$this->encrypt->setKey(substr($key, 0, $encryptKeyLength));
}
if ($this->decrypt) {
$this->decrypt->enableContinuousBuffer();
$this->decrypt->disablePadding();
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$iv = $kexHash->hash($keyBytes . $this->exchange_hash . 'B' . $this->session_id);
added phpseclib
2010-05-14 14:06:17 +00:00
while ($this->decrypt_block_size > strlen($iv)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$iv.= $kexHash->hash($keyBytes . $this->exchange_hash . $iv);
added phpseclib
2010-05-14 14:06:17 +00:00
}
$this->decrypt->setIV(substr($iv, 0, $this->decrypt_block_size));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key = $kexHash->hash($keyBytes . $this->exchange_hash . 'D' . $this->session_id);
added phpseclib
2010-05-14 14:06:17 +00:00
while ($decryptKeyLength > strlen($key)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key.= $kexHash->hash($keyBytes . $this->exchange_hash . $key);
added phpseclib
2010-05-14 14:06:17 +00:00
}
$this->decrypt->setKey(substr($key, 0, $decryptKeyLength));
}
/* The "arcfour128" algorithm is the RC4 cipher, as described in
[SCHNEIER], using a 128-bit key. The first 1536 bytes of keystream
generated by the cipher MUST be discarded, and the first byte of the
first encrypted packet MUST be encrypted using the 1537th byte of
keystream.
-- http://tools.ietf.org/html/rfc4345#section-4 */
if ($encrypt == 'arcfour128' || $encrypt == 'arcfour256') {
$this->encrypt->encrypt(str_repeat("\0", 1536));
}
if ($decrypt == 'arcfour128' || $decrypt == 'arcfour256') {
$this->decrypt->decrypt(str_repeat("\0", 1536));
}
for ($i = 0; $i < count($mac_algorithms) && !in_array($mac_algorithms[$i], $this->mac_algorithms_client_to_server); $i++);
if ($i == count($mac_algorithms)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('No compatible client to server message authentication algorithms found');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
$createKeyLength = 0; // ie. $mac_algorithms[$i] == 'none'
switch ($mac_algorithms[$i]) {
case 'hmac-sha1':
$this->hmac_create = new Crypt_Hash('sha1');
$createKeyLength = 20;
break;
case 'hmac-sha1-96':
$this->hmac_create = new Crypt_Hash('sha1-96');
$createKeyLength = 20;
break;
case 'hmac-md5':
$this->hmac_create = new Crypt_Hash('md5');
$createKeyLength = 16;
break;
case 'hmac-md5-96':
$this->hmac_create = new Crypt_Hash('md5-96');
$createKeyLength = 16;
}
for ($i = 0; $i < count($mac_algorithms) && !in_array($mac_algorithms[$i], $this->mac_algorithms_server_to_client); $i++);
if ($i == count($mac_algorithms)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('No compatible server to client message authentication algorithms found');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
$checkKeyLength = 0;
$this->hmac_size = 0;
switch ($mac_algorithms[$i]) {
case 'hmac-sha1':
$this->hmac_check = new Crypt_Hash('sha1');
$checkKeyLength = 20;
$this->hmac_size = 20;
break;
case 'hmac-sha1-96':
$this->hmac_check = new Crypt_Hash('sha1-96');
$checkKeyLength = 20;
$this->hmac_size = 12;
break;
case 'hmac-md5':
$this->hmac_check = new Crypt_Hash('md5');
$checkKeyLength = 16;
$this->hmac_size = 16;
break;
case 'hmac-md5-96':
$this->hmac_check = new Crypt_Hash('md5-96');
$checkKeyLength = 16;
$this->hmac_size = 12;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key = $kexHash->hash($keyBytes . $this->exchange_hash . 'E' . $this->session_id);
added phpseclib
2010-05-14 14:06:17 +00:00
while ($createKeyLength > strlen($key)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key.= $kexHash->hash($keyBytes . $this->exchange_hash . $key);
added phpseclib
2010-05-14 14:06:17 +00:00
}
$this->hmac_create->setKey(substr($key, 0, $createKeyLength));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key = $kexHash->hash($keyBytes . $this->exchange_hash . 'F' . $this->session_id);
added phpseclib
2010-05-14 14:06:17 +00:00
while ($checkKeyLength > strlen($key)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$key.= $kexHash->hash($keyBytes . $this->exchange_hash . $key);
added phpseclib
2010-05-14 14:06:17 +00:00
}
$this->hmac_check->setKey(substr($key, 0, $checkKeyLength));
for ($i = 0; $i < count($compression_algorithms) && !in_array($compression_algorithms[$i], $this->compression_algorithms_server_to_client); $i++);
if ($i == count($compression_algorithms)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('No compatible server to client compression algorithms found');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
$this->decompress = $compression_algorithms[$i] == 'zlib';
for ($i = 0; $i < count($compression_algorithms) && !in_array($compression_algorithms[$i], $this->compression_algorithms_client_to_server); $i++);
if ($i == count($compression_algorithms)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('No compatible client to server compression algorithms found');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
$this->compress = $compression_algorithms[$i] == 'zlib';
return true;
}
/**
* Login
*
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* The $password parameter can be a plaintext password, a Crypt_RSA object or an array
new phpseclib
2011-05-19 18:02:11 +00:00
*
added phpseclib
2010-05-14 14:06:17 +00:00
* @param String $username
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* @param Mixed $password
* @param Mixed $...
added phpseclib
2010-05-14 14:06:17 +00:00
* @return Boolean
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* @see _login
added phpseclib
2010-05-14 14:06:17 +00:00
* @access public
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
function login($username)
{
$args = func_get_args();
return call_user_func_array(array(&$this, '_login'), $args);
}
/**
* Login Helper
*
* @param String $username
* @param Mixed $password
* @param Mixed $...
* @return Boolean
* @see _login_helper
* @access private
*/
function _login($username)
{
$args = array_slice(func_get_args(), 1);
if (empty($args)) {
return $this->_login_helper($username);
}
foreach ($args as $arg) {
if ($this->_login_helper($username, $arg)) {
return true;
}
}
return false;
}
/**
* Login Helper
*
* @param String $username
* @param optional String $password
* @return Boolean
* @access private
* @internal It might be worthwhile, at some point, to protect against {@link http://tools.ietf.org/html/rfc4251#section-9.3.9 traffic analysis}
* by sending dummy SSH_MSG_IGNORE messages.
*/
function _login_helper($username, $password = null)
added phpseclib
2010-05-14 14:06:17 +00:00
{
if (!($this->bitmap & NET_SSH2_MASK_CONSTRUCTOR)) {
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!($this->bitmap & NET_SSH2_MASK_LOGIN_REQ)) {
$packet = pack('CNa*',
NET_SSH2_MSG_SERVICE_REQUEST, strlen('ssh-userauth'), 'ssh-userauth'
);
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!$this->_send_binary_packet($packet)) {
return false;
}
$response = $this->_get_binary_packet();
if ($response === false) {
user_error('Connection closed by server');
return false;
}
extract(unpack('Ctype', $this->_string_shift($response, 1)));
if ($type != NET_SSH2_MSG_SERVICE_ACCEPT) {
user_error('Expected SSH_MSG_SERVICE_ACCEPT');
return false;
}
$this->bitmap |= NET_SSH2_MASK_LOGIN_REQ;
added phpseclib
2010-05-14 14:06:17 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (strlen($this->last_interactive_response)) {
return !is_string($password) && !is_array($password) ? false : $this->_keyboard_interactive_process($password);
added phpseclib
2010-05-14 14:06:17 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// although PHP5's get_class() preserves the case, PHP4's does not
if (is_object($password)) {
switch (strtolower(get_class($password))) {
case 'crypt_rsa':
return $this->_privatekey_login($username, $password);
case 'system_ssh_agent':
return $this->_ssh_agent_login($username, $password);
}
}
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (is_array($password)) {
if ($this->_keyboard_interactive_login($username, $password)) {
$this->bitmap |= NET_SSH2_MASK_LOGIN;
return true;
}
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!isset($password)) {
$packet = pack('CNa*Na*Na*',
NET_SSH2_MSG_USERAUTH_REQUEST, strlen($username), $username, strlen('ssh-connection'), 'ssh-connection',
strlen('none'), 'none'
);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$response = $this->_get_binary_packet();
if ($response === false) {
user_error('Connection closed by server');
return false;
}
extract(unpack('Ctype', $this->_string_shift($response, 1)));
switch ($type) {
case NET_SSH2_MSG_USERAUTH_SUCCESS:
$this->bitmap |= NET_SSH2_MASK_LOGIN;
return true;
//case NET_SSH2_MSG_USERAUTH_FAILURE:
default:
return false;
}
added phpseclib
2010-05-14 14:06:17 +00:00
}
$packet = pack('CNa*Na*Na*CNa*',
NET_SSH2_MSG_USERAUTH_REQUEST, strlen($username), $username, strlen('ssh-connection'), 'ssh-connection',
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
strlen('password'), 'password', 0, strlen($password), $password
added phpseclib
2010-05-14 14:06:17 +00:00
);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// remove the username and password from the logged packet
if (!defined('NET_SSH2_LOGGING')) {
$logged = null;
} else {
$logged = pack('CNa*Na*Na*CNa*',
added phpseclib
2010-05-14 14:06:17 +00:00
NET_SSH2_MSG_USERAUTH_REQUEST, strlen('username'), 'username', strlen('ssh-connection'), 'ssh-connection',
strlen('password'), 'password', 0, strlen('password'), 'password'
);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
}
if (!$this->_send_binary_packet($packet, $logged)) {
return false;
added phpseclib
2010-05-14 14:06:17 +00:00
}
$response = $this->_get_binary_packet();
if ($response === false) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
extract(unpack('Ctype', $this->_string_shift($response, 1)));
switch ($type) {
case NET_SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ: // in theory, the password can be changed
if (defined('NET_SSH2_LOGGING')) {
$this->message_number_log[count($this->message_number_log) - 1] = 'NET_SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ';
}
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$this->errors[] = 'SSH_MSG_USERAUTH_PASSWD_CHANGEREQ: ' . utf8_decode($this->_string_shift($response, $length));
return $this->_disconnect(NET_SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER);
case NET_SSH2_MSG_USERAUTH_FAILURE:
new phpseclib
2011-05-19 18:02:11 +00:00
// can we use keyboard-interactive authentication? if not then either the login is bad or the server employees
// multi-factor authentication
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$auth_methods = explode(',', $this->_string_shift($response, $length));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
extract(unpack('Cpartial_success', $this->_string_shift($response, 1)));
$partial_success = $partial_success != 0;
if (!$partial_success && in_array('keyboard-interactive', $auth_methods)) {
new phpseclib
2011-05-19 18:02:11 +00:00
if ($this->_keyboard_interactive_login($username, $password)) {
$this->bitmap |= NET_SSH2_MASK_LOGIN;
return true;
}
return false;
}
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
case NET_SSH2_MSG_USERAUTH_SUCCESS:
$this->bitmap |= NET_SSH2_MASK_LOGIN;
return true;
}
return false;
}
new phpseclib
2011-05-19 18:02:11 +00:00
/**
* Login via keyboard-interactive authentication
*
* See {@link http://tools.ietf.org/html/rfc4256 RFC4256} for details. This is not a full-featured keyboard-interactive authenticator.
*
* @param String $username
* @param String $password
* @return Boolean
* @access private
*/
function _keyboard_interactive_login($username, $password)
{
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$packet = pack('CNa*Na*Na*Na*Na*',
new phpseclib
2011-05-19 18:02:11 +00:00
NET_SSH2_MSG_USERAUTH_REQUEST, strlen($username), $username, strlen('ssh-connection'), 'ssh-connection',
strlen('keyboard-interactive'), 'keyboard-interactive', 0, '', 0, ''
);
if (!$this->_send_binary_packet($packet)) {
return false;
}
return $this->_keyboard_interactive_process($password);
}
/**
* Handle the keyboard-interactive requests / responses.
*
* @param String $responses...
* @return Boolean
* @access private
*/
function _keyboard_interactive_process()
{
$responses = func_get_args();
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (strlen($this->last_interactive_response)) {
$response = $this->last_interactive_response;
} else {
$orig = $response = $this->_get_binary_packet();
if ($response === false) {
user_error('Connection closed by server');
return false;
}
new phpseclib
2011-05-19 18:02:11 +00:00
}
extract(unpack('Ctype', $this->_string_shift($response, 1)));
switch ($type) {
case NET_SSH2_MSG_USERAUTH_INFO_REQUEST:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$this->_string_shift($response, $length); // name; may be empty
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$this->_string_shift($response, $length); // instruction; may be empty
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$this->_string_shift($response, $length); // language tag; may be empty
extract(unpack('Nnum_prompts', $this->_string_shift($response, 4)));
for ($i = 0; $i < count($responses); $i++) {
if (is_array($responses[$i])) {
foreach ($responses[$i] as $key => $value) {
$this->keyboard_requests_responses[$key] = $value;
}
unset($responses[$i]);
}
}
$responses = array_values($responses);
if (isset($this->keyboard_requests_responses)) {
for ($i = 0; $i < $num_prompts; $i++) {
extract(unpack('Nlength', $this->_string_shift($response, 4)));
// prompt - ie. "Password: "; must not be empty
$prompt = $this->_string_shift($response, $length);
//$echo = $this->_string_shift($response) != chr(0);
foreach ($this->keyboard_requests_responses as $key => $value) {
if (substr($prompt, 0, strlen($key)) == $key) {
$responses[] = $value;
break;
}
}
}
}
new phpseclib
2011-05-19 18:02:11 +00:00
// see http://tools.ietf.org/html/rfc4256#section-3.2
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (strlen($this->last_interactive_response)) {
$this->last_interactive_response = '';
} else if (defined('NET_SSH2_LOGGING')) {
new phpseclib
2011-05-19 18:02:11 +00:00
$this->message_number_log[count($this->message_number_log) - 1] = str_replace(
'UNKNOWN',
'NET_SSH2_MSG_USERAUTH_INFO_REQUEST',
$this->message_number_log[count($this->message_number_log) - 1]
);
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!count($responses) && $num_prompts) {
$this->last_interactive_response = $orig;
$this->bitmap |= NET_SSH_MASK_LOGIN_INTERACTIVE;
return false;
new phpseclib
2011-05-19 18:02:11 +00:00
}
/*
After obtaining the requested information from the user, the client
MUST respond with an SSH_MSG_USERAUTH_INFO_RESPONSE message.
*/
// see http://tools.ietf.org/html/rfc4256#section-3.4
$packet = $logged = pack('CN', NET_SSH2_MSG_USERAUTH_INFO_RESPONSE, count($responses));
for ($i = 0; $i < count($responses); $i++) {
$packet.= pack('Na*', strlen($responses[$i]), $responses[$i]);
$logged.= pack('Na*', strlen('dummy-answer'), 'dummy-answer');
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!$this->_send_binary_packet($packet, $logged)) {
new phpseclib
2011-05-19 18:02:11 +00:00
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (defined('NET_SSH2_LOGGING') && NET_SSH2_LOGGING == NET_SSH2_LOG_COMPLEX) {
new phpseclib
2011-05-19 18:02:11 +00:00
$this->message_number_log[count($this->message_number_log) - 1] = str_replace(
'UNKNOWN',
'NET_SSH2_MSG_USERAUTH_INFO_RESPONSE',
$this->message_number_log[count($this->message_number_log) - 1]
);
}
/*
After receiving the response, the server MUST send either an
SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, or another
SSH_MSG_USERAUTH_INFO_REQUEST message.
*/
// maybe phpseclib should force close the connection after x request / responses? unless something like that is done
// there could be an infinite loop of request / responses.
return $this->_keyboard_interactive_process();
case NET_SSH2_MSG_USERAUTH_SUCCESS:
return true;
case NET_SSH2_MSG_USERAUTH_FAILURE:
return false;
}
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Login with an ssh-agent provided key
*
* @param String $username
* @param System_SSH_Agent $agent
* @return Boolean
* @access private
*/
function _ssh_agent_login($username, $agent)
{
$keys = $agent->requestIdentities();
foreach ($keys as $key) {
if ($this->_privatekey_login($username, $key)) {
return true;
}
}
return false;
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Login with an RSA private key
*
* @param String $username
* @param Crypt_RSA $password
* @return Boolean
* @access private
* @internal It might be worthwhile, at some point, to protect against {@link http://tools.ietf.org/html/rfc4251#section-9.3.9 traffic analysis}
* by sending dummy SSH_MSG_IGNORE messages.
*/
function _privatekey_login($username, $privatekey)
{
// see http://tools.ietf.org/html/rfc4253#page-15
$publickey = $privatekey->getPublicKey(CRYPT_RSA_PUBLIC_FORMAT_RAW);
if ($publickey === false) {
return false;
}
$publickey = array(
'e' => $publickey['e']->toBytes(true),
'n' => $publickey['n']->toBytes(true)
);
$publickey = pack('Na*Na*Na*',
strlen('ssh-rsa'), 'ssh-rsa', strlen($publickey['e']), $publickey['e'], strlen($publickey['n']), $publickey['n']
);
$part1 = pack('CNa*Na*Na*',
NET_SSH2_MSG_USERAUTH_REQUEST, strlen($username), $username, strlen('ssh-connection'), 'ssh-connection',
strlen('publickey'), 'publickey'
);
$part2 = pack('Na*Na*', strlen('ssh-rsa'), 'ssh-rsa', strlen($publickey), $publickey);
$packet = $part1 . chr(0) . $part2;
if (!$this->_send_binary_packet($packet)) {
return false;
}
$response = $this->_get_binary_packet();
if ($response === false) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
extract(unpack('Ctype', $this->_string_shift($response, 1)));
switch ($type) {
case NET_SSH2_MSG_USERAUTH_FAILURE:
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$this->errors[] = 'SSH_MSG_USERAUTH_FAILURE: ' . $this->_string_shift($response, $length);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
return false;
added phpseclib
2010-05-14 14:06:17 +00:00
case NET_SSH2_MSG_USERAUTH_PK_OK:
// we'll just take it on faith that the public key blob and the public key algorithm name are as
// they should be
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (defined('NET_SSH2_LOGGING') && NET_SSH2_LOGGING == NET_SSH2_LOG_COMPLEX) {
new phpseclib
2011-05-19 18:02:11 +00:00
$this->message_number_log[count($this->message_number_log) - 1] = str_replace(
'UNKNOWN',
'NET_SSH2_MSG_USERAUTH_PK_OK',
$this->message_number_log[count($this->message_number_log) - 1]
);
added phpseclib
2010-05-14 14:06:17 +00:00
}
}
$packet = $part1 . chr(1) . $part2;
$privatekey->setSignatureMode(CRYPT_RSA_SIGNATURE_PKCS1);
$signature = $privatekey->sign(pack('Na*a*', strlen($this->session_id), $this->session_id, $packet));
$signature = pack('Na*Na*', strlen('ssh-rsa'), 'ssh-rsa', strlen($signature), $signature);
$packet.= pack('Na*', strlen($signature), $signature);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$response = $this->_get_binary_packet();
if ($response === false) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
extract(unpack('Ctype', $this->_string_shift($response, 1)));
switch ($type) {
case NET_SSH2_MSG_USERAUTH_FAILURE:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// either the login is bad or the server employs multi-factor authentication
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
case NET_SSH2_MSG_USERAUTH_SUCCESS:
$this->bitmap |= NET_SSH2_MASK_LOGIN;
return true;
}
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Set Timeout
*
* $ssh->exec('ping 127.0.0.1'); on a Linux host will never return and will run indefinitely. setTimeout() makes it so it'll timeout.
* Setting $timeout to false or 0 will mean there is no timeout.
*
* @param Mixed $timeout
* @access public
*/
function setTimeout($timeout)
{
$this->timeout = $this->curTimeout = $timeout;
}
/**
* Get the output from stdError
*
* @access public
*/
function getStdError()
{
return $this->stdErrorLog;
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Execute Command
*
new phpseclib
2011-05-19 18:02:11 +00:00
* If $block is set to false then Net_SSH2::_get_channel_packet(NET_SSH2_CHANNEL_EXEC) will need to be called manually.
* In all likelihood, this is not a feature you want to be taking advantage of.
*
added phpseclib
2010-05-14 14:06:17 +00:00
* @param String $command
new phpseclib
2011-05-19 18:02:11 +00:00
* @param optional Boolean $block
added phpseclib
2010-05-14 14:06:17 +00:00
* @return String
* @access public
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
function exec($command, $callback = null)
added phpseclib
2010-05-14 14:06:17 +00:00
{
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->curTimeout = $this->timeout;
$this->is_timeout = false;
$this->stdErrorLog = '';
added phpseclib
2010-05-14 14:06:17 +00:00
if (!($this->bitmap & NET_SSH2_MASK_LOGIN)) {
return false;
}
// RFC4254 defines the (client) window size as "bytes the other party can send before it must wait for the window to
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// be adjusted". 0x7FFFFFFF is, at 2GB, the max size. technically, it should probably be decremented, but,
// honestly, if you're transfering more than 2GB, you probably shouldn't be using phpseclib, anyway.
added phpseclib
2010-05-14 14:06:17 +00:00
// see http://tools.ietf.org/html/rfc4254#section-5.2 for more info
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->window_size_server_to_client[NET_SSH2_CHANNEL_EXEC] = 0x7FFFFFFF;
added phpseclib
2010-05-14 14:06:17 +00:00
// 0x8000 is the maximum max packet size, per http://tools.ietf.org/html/rfc4253#section-6.1, although since PuTTy
// uses 0x4000, that's what will be used here, as well.
$packet_size = 0x4000;
$packet = pack('CNa*N3',
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
NET_SSH2_MSG_CHANNEL_OPEN, strlen('session'), 'session', NET_SSH2_CHANNEL_EXEC, $this->window_size_server_to_client[NET_SSH2_CHANNEL_EXEC], $packet_size);
added phpseclib
2010-05-14 14:06:17 +00:00
if (!$this->_send_binary_packet($packet)) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_EXEC] = NET_SSH2_MSG_CHANNEL_OPEN;
$response = $this->_get_channel_packet(NET_SSH2_CHANNEL_EXEC);
if ($response === false) {
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($this->request_pty === true) {
$terminal_modes = pack('C', NET_SSH2_TTY_OP_END);
$packet = pack('CNNa*CNa*N5a*',
NET_SSH2_MSG_CHANNEL_REQUEST, $this->server_channels[NET_SSH2_CHANNEL_EXEC], strlen('pty-req'), 'pty-req', 1, strlen('vt100'), 'vt100',
80, 24, 0, 0, strlen($terminal_modes), $terminal_modes);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$response = $this->_get_binary_packet();
if ($response === false) {
user_error('Connection closed by server');
return false;
}
list(, $type) = unpack('C', $this->_string_shift($response, 1));
switch ($type) {
case NET_SSH2_MSG_CHANNEL_SUCCESS:
break;
case NET_SSH2_MSG_CHANNEL_FAILURE:
default:
user_error('Unable to request pseudo-terminal');
return $this->_disconnect(NET_SSH2_DISCONNECT_BY_APPLICATION);
}
$this->in_request_pty_exec = true;
}
added phpseclib
2010-05-14 14:06:17 +00:00
// sending a pty-req SSH_MSG_CHANNEL_REQUEST message is unnecessary and, in fact, in most cases, slows things
// down. the one place where it might be desirable is if you're doing something like Net_SSH2::exec('ping localhost &').
new phpseclib
2011-05-19 18:02:11 +00:00
// with a pty-req SSH_MSG_CHANNEL_REQUEST, exec() will return immediately and the ping process will then
added phpseclib
2010-05-14 14:06:17 +00:00
// then immediately terminate. without such a request exec() will loop indefinitely. the ping process won't end but
// neither will your script.
// although, in theory, the size of SSH_MSG_CHANNEL_REQUEST could exceed the maximum packet size established by
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// SSH_MSG_CHANNEL_OPEN_CONFIRMATION, RFC4254#section-5.1 states that the "maximum packet size" refers to the
added phpseclib
2010-05-14 14:06:17 +00:00
// "maximum size of an individual data packet". ie. SSH_MSG_CHANNEL_DATA. RFC4254#section-5.2 corroborates.
$packet = pack('CNNa*CNa*',
NET_SSH2_MSG_CHANNEL_REQUEST, $this->server_channels[NET_SSH2_CHANNEL_EXEC], strlen('exec'), 'exec', 1, strlen($command), $command);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_EXEC] = NET_SSH2_MSG_CHANNEL_REQUEST;
$response = $this->_get_channel_packet(NET_SSH2_CHANNEL_EXEC);
if ($response === false) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_EXEC] = NET_SSH2_MSG_CHANNEL_DATA;
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($callback === false || $this->in_request_pty_exec) {
new phpseclib
2011-05-19 18:02:11 +00:00
return true;
}
added phpseclib
2010-05-14 14:06:17 +00:00
$output = '';
while (true) {
$temp = $this->_get_channel_packet(NET_SSH2_CHANNEL_EXEC);
switch (true) {
case $temp === true:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
return is_callable($callback) ? true : $output;
added phpseclib
2010-05-14 14:06:17 +00:00
case $temp === false:
return false;
default:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (is_callable($callback)) {
$callback($temp);
} else {
$output.= $temp;
}
added phpseclib
2010-05-14 14:06:17 +00:00
}
}
}
new phpseclib
2011-05-19 18:02:11 +00:00
/**
* Creates an interactive shell
*
* @see Net_SSH2::read()
* @see Net_SSH2::write()
* @return Boolean
* @access private
*/
function _initShell()
{
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($this->in_request_pty_exec === true) {
return true;
}
$this->window_size_server_to_client[NET_SSH2_CHANNEL_SHELL] = 0x7FFFFFFF;
new phpseclib
2011-05-19 18:02:11 +00:00
$packet_size = 0x4000;
$packet = pack('CNa*N3',
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
NET_SSH2_MSG_CHANNEL_OPEN, strlen('session'), 'session', NET_SSH2_CHANNEL_SHELL, $this->window_size_server_to_client[NET_SSH2_CHANNEL_SHELL], $packet_size);
new phpseclib
2011-05-19 18:02:11 +00:00
if (!$this->_send_binary_packet($packet)) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_SHELL] = NET_SSH2_MSG_CHANNEL_OPEN;
$response = $this->_get_channel_packet(NET_SSH2_CHANNEL_SHELL);
if ($response === false) {
return false;
}
$terminal_modes = pack('C', NET_SSH2_TTY_OP_END);
$packet = pack('CNNa*CNa*N5a*',
NET_SSH2_MSG_CHANNEL_REQUEST, $this->server_channels[NET_SSH2_CHANNEL_SHELL], strlen('pty-req'), 'pty-req', 1, strlen('vt100'), 'vt100',
80, 24, 0, 0, strlen($terminal_modes), $terminal_modes);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$response = $this->_get_binary_packet();
if ($response === false) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
new phpseclib
2011-05-19 18:02:11 +00:00
return false;
}
list(, $type) = unpack('C', $this->_string_shift($response, 1));
switch ($type) {
case NET_SSH2_MSG_CHANNEL_SUCCESS:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// if a pty can't be opened maybe commands can still be executed
new phpseclib
2011-05-19 18:02:11 +00:00
case NET_SSH2_MSG_CHANNEL_FAILURE:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
break;
new phpseclib
2011-05-19 18:02:11 +00:00
default:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Unable to request pseudo-terminal');
new phpseclib
2011-05-19 18:02:11 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_BY_APPLICATION);
}
$packet = pack('CNNa*C',
NET_SSH2_MSG_CHANNEL_REQUEST, $this->server_channels[NET_SSH2_CHANNEL_SHELL], strlen('shell'), 'shell', 1);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_SHELL] = NET_SSH2_MSG_CHANNEL_REQUEST;
$response = $this->_get_channel_packet(NET_SSH2_CHANNEL_SHELL);
if ($response === false) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_SHELL] = NET_SSH2_MSG_CHANNEL_DATA;
$this->bitmap |= NET_SSH2_MASK_SHELL;
return true;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Return the channel to be used with read() / write()
*
* @see Net_SSH2::read()
* @see Net_SSH2::write()
* @return Integer
* @access public
*/
function _get_interactive_channel()
{
switch (true) {
case $this->in_subsystem:
return NET_SSH2_CHANNEL_SUBSYSTEM;
case $this->in_request_pty_exec:
return NET_SSH2_CHANNEL_EXEC;
default:
return NET_SSH2_CHANNEL_SHELL;
}
}
new phpseclib
2011-05-19 18:02:11 +00:00
/**
* Returns the output of an interactive shell
*
* Returns when there's a match for $expect, which can take the form of a string literal or,
* if $mode == NET_SSH2_READ_REGEX, a regular expression.
*
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* @see Net_SSH2::write()
new phpseclib
2011-05-19 18:02:11 +00:00
* @param String $expect
* @param Integer $mode
* @return String
* @access public
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
function read($expect = '', $mode = NET_SSH2_READ_SIMPLE)
new phpseclib
2011-05-19 18:02:11 +00:00
{
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->curTimeout = $this->timeout;
$this->is_timeout = false;
new phpseclib
2011-05-19 18:02:11 +00:00
if (!($this->bitmap & NET_SSH2_MASK_LOGIN)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Operation disallowed prior to login()');
new phpseclib
2011-05-19 18:02:11 +00:00
return false;
}
if (!($this->bitmap & NET_SSH2_MASK_SHELL) && !$this->_initShell()) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Unable to initiate an interactive shell session');
new phpseclib
2011-05-19 18:02:11 +00:00
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$channel = $this->_get_interactive_channel();
new phpseclib
2011-05-19 18:02:11 +00:00
$match = $expect;
while (true) {
if ($mode == NET_SSH2_READ_REGEX) {
preg_match($expect, $this->interactiveBuffer, $matches);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$match = isset($matches[0]) ? $matches[0] : '';
new phpseclib
2011-05-19 18:02:11 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$pos = strlen($match) ? strpos($this->interactiveBuffer, $match) : false;
new phpseclib
2011-05-19 18:02:11 +00:00
if ($pos !== false) {
return $this->_string_shift($this->interactiveBuffer, $pos + strlen($match));
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$response = $this->_get_channel_packet($channel);
if (is_bool($response)) {
$this->in_request_pty_exec = false;
return $response ? $this->_string_shift($this->interactiveBuffer, strlen($this->interactiveBuffer)) : false;
}
new phpseclib
2011-05-19 18:02:11 +00:00
$this->interactiveBuffer.= $response;
}
}
/**
* Inputs a command into an interactive shell.
*
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* @see Net_SSH2::read()
new phpseclib
2011-05-19 18:02:11 +00:00
* @param String $cmd
* @return Boolean
* @access public
*/
function write($cmd)
{
if (!($this->bitmap & NET_SSH2_MASK_LOGIN)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Operation disallowed prior to login()');
new phpseclib
2011-05-19 18:02:11 +00:00
return false;
}
if (!($this->bitmap & NET_SSH2_MASK_SHELL) && !$this->_initShell()) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Unable to initiate an interactive shell session');
new phpseclib
2011-05-19 18:02:11 +00:00
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
return $this->_send_channel_packet($this->_get_interactive_channel(), $cmd);
}
/**
* Start a subsystem.
*
* Right now only one subsystem at a time is supported. To support multiple subsystem's stopSubsystem() could accept
* a string that contained the name of the subsystem, but at that point, only one subsystem of each type could be opened.
* To support multiple subsystem's of the same name maybe it'd be best if startSubsystem() generated a new channel id and
* returns that and then that that was passed into stopSubsystem() but that'll be saved for a future date and implemented
* if there's sufficient demand for such a feature.
*
* @see Net_SSH2::stopSubsystem()
* @param String $subsystem
* @return Boolean
* @access public
*/
function startSubsystem($subsystem)
{
$this->window_size_server_to_client[NET_SSH2_CHANNEL_SUBSYSTEM] = $this->window_size;
$packet = pack('CNa*N3',
NET_SSH2_MSG_CHANNEL_OPEN, strlen('session'), 'session', NET_SSH2_CHANNEL_SUBSYSTEM, $this->window_size, 0x4000);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_SUBSYSTEM] = NET_SSH2_MSG_CHANNEL_OPEN;
$response = $this->_get_channel_packet(NET_SSH2_CHANNEL_SUBSYSTEM);
if ($response === false) {
return false;
}
$packet = pack('CNNa*CNa*',
NET_SSH2_MSG_CHANNEL_REQUEST, $this->server_channels[NET_SSH2_CHANNEL_SUBSYSTEM], strlen('subsystem'), 'subsystem', 1, strlen($subsystem), $subsystem);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_SUBSYSTEM] = NET_SSH2_MSG_CHANNEL_REQUEST;
$response = $this->_get_channel_packet(NET_SSH2_CHANNEL_SUBSYSTEM);
if ($response === false) {
return false;
}
$this->channel_status[NET_SSH2_CHANNEL_SUBSYSTEM] = NET_SSH2_MSG_CHANNEL_DATA;
$this->bitmap |= NET_SSH2_MASK_SHELL;
$this->in_subsystem = true;
return true;
}
/**
* Stops a subsystem.
*
* @see Net_SSH2::startSubsystem()
* @return Boolean
* @access public
*/
function stopSubsystem()
{
$this->in_subsystem = false;
$this->_close_channel(NET_SSH2_CHANNEL_SUBSYSTEM);
return true;
}
/**
* Closes a channel
*
* If read() timed out you might want to just close the channel and have it auto-restart on the next read() call
*
* @access public
*/
function reset()
{
$this->_close_channel($this->_get_interactive_channel());
}
/**
* Is timeout?
*
* Did exec() or read() return because they timed out or because they encountered the end?
*
* @access public
*/
function isTimeout()
{
return $this->is_timeout;
new phpseclib
2011-05-19 18:02:11 +00:00
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Disconnect
*
* @access public
*/
function disconnect()
{
$this->_disconnect(NET_SSH2_DISCONNECT_BY_APPLICATION);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (isset($this->realtime_log_file) && is_resource($this->realtime_log_file)) {
fclose($this->realtime_log_file);
}
added phpseclib
2010-05-14 14:06:17 +00:00
}
/**
* Destructor.
*
* Will be called, automatically, if you're supporting just PHP5. If you're supporting PHP4, you'll need to call
* disconnect().
*
* @access public
*/
function __destruct()
{
$this->disconnect();
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Is the connection still active?
*
* @access public
*/
function isConnected()
{
return $this->bitmap & NET_SSH2_MASK_LOGIN;
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Gets Binary Packets
*
* See '6. Binary Packet Protocol' of rfc4253 for more info.
*
* @see Net_SSH2::_send_binary_packet()
* @return String
* @access private
*/
function _get_binary_packet()
{
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!is_resource($this->fsock) || feof($this->fsock)) {
user_error('Connection closed prematurely');
$this->bitmap = 0;
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
$start = strtok(microtime(), ' ') + strtok(''); // http://php.net/microtime#61838
$raw = fread($this->fsock, $this->decrypt_block_size);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!strlen($raw)) {
new phpseclib
2011-05-19 18:02:11 +00:00
return '';
}
added phpseclib
2010-05-14 14:06:17 +00:00
if ($this->decrypt !== false) {
$raw = $this->decrypt->decrypt($raw);
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($raw === false) {
user_error('Unable to decrypt content');
return false;
}
added phpseclib
2010-05-14 14:06:17 +00:00
extract(unpack('Npacket_length/Cpadding_length', $this->_string_shift($raw, 5)));
$remaining_length = $packet_length + 4 - $this->decrypt_block_size;
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// quoting <http://tools.ietf.org/html/rfc4253#section-6.1>,
// "implementations SHOULD check that the packet length is reasonable"
// PuTTY uses 0x9000 as the actual max packet size and so to shall we
if ($remaining_length < -$this->decrypt_block_size || $remaining_length > 0x9000 || $remaining_length % $this->decrypt_block_size != 0) {
user_error('Invalid size');
return false;
}
added phpseclib
2010-05-14 14:06:17 +00:00
$buffer = '';
while ($remaining_length > 0) {
$temp = fread($this->fsock, $remaining_length);
$buffer.= $temp;
$remaining_length-= strlen($temp);
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$stop = strtok(microtime(), ' ') + strtok('');
if (strlen($buffer)) {
added phpseclib
2010-05-14 14:06:17 +00:00
$raw.= $this->decrypt !== false ? $this->decrypt->decrypt($buffer) : $buffer;
}
$payload = $this->_string_shift($raw, $packet_length - $padding_length - 1);
$padding = $this->_string_shift($raw, $padding_length); // should leave $raw empty
if ($this->hmac_check !== false) {
$hmac = fread($this->fsock, $this->hmac_size);
if ($hmac != $this->hmac_check->hash(pack('NNCa*', $this->get_seq_no, $packet_length, $padding_length, $payload . $padding))) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Invalid HMAC');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
}
//if ($this->decompress) {
// $payload = gzinflate(substr($payload, 2));
//}
$this->get_seq_no++;
if (defined('NET_SSH2_LOGGING')) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$current = strtok(microtime(), ' ') + strtok('');
$message_number = isset($this->message_numbers[ord($payload[0])]) ? $this->message_numbers[ord($payload[0])] : 'UNKNOWN (' . ord($payload[0]) . ')';
$message_number = '<- ' . $message_number .
' (since last: ' . round($current - $this->last_packet, 4) . ', network: ' . round($stop - $start, 4) . 's)';
$this->_append_log($message_number, $payload);
$this->last_packet = $current;
added phpseclib
2010-05-14 14:06:17 +00:00
}
return $this->_filter($payload);
}
/**
* Filter Binary Packets
*
* Because some binary packets need to be ignored...
*
* @see Net_SSH2::_get_binary_packet()
* @return String
* @access private
*/
function _filter($payload)
{
switch (ord($payload[0])) {
case NET_SSH2_MSG_DISCONNECT:
$this->_string_shift($payload, 1);
extract(unpack('Nreason_code/Nlength', $this->_string_shift($payload, 8)));
$this->errors[] = 'SSH_MSG_DISCONNECT: ' . $this->disconnect_reasons[$reason_code] . "\r\n" . utf8_decode($this->_string_shift($payload, $length));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->bitmap = 0;
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
case NET_SSH2_MSG_IGNORE:
$payload = $this->_get_binary_packet();
break;
case NET_SSH2_MSG_DEBUG:
$this->_string_shift($payload, 2);
extract(unpack('Nlength', $this->_string_shift($payload, 4)));
$this->errors[] = 'SSH_MSG_DEBUG: ' . utf8_decode($this->_string_shift($payload, $length));
$payload = $this->_get_binary_packet();
break;
case NET_SSH2_MSG_UNIMPLEMENTED:
return false;
case NET_SSH2_MSG_KEXINIT:
if ($this->session_id !== false) {
if (!$this->_key_exchange($payload)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->bitmap = 0;
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
$payload = $this->_get_binary_packet();
}
}
// see http://tools.ietf.org/html/rfc4252#section-5.4; only called when the encryption has been activated and when we haven't already logged in
if (($this->bitmap & NET_SSH2_MASK_CONSTRUCTOR) && !($this->bitmap & NET_SSH2_MASK_LOGIN) && ord($payload[0]) == NET_SSH2_MSG_USERAUTH_BANNER) {
$this->_string_shift($payload, 1);
extract(unpack('Nlength', $this->_string_shift($payload, 4)));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->banner_message = utf8_decode($this->_string_shift($payload, $length));
added phpseclib
2010-05-14 14:06:17 +00:00
$payload = $this->_get_binary_packet();
}
// only called when we've already logged in
if (($this->bitmap & NET_SSH2_MASK_CONSTRUCTOR) && ($this->bitmap & NET_SSH2_MASK_LOGIN)) {
switch (ord($payload[0])) {
case NET_SSH2_MSG_GLOBAL_REQUEST: // see http://tools.ietf.org/html/rfc4254#section-4
$this->_string_shift($payload, 1);
extract(unpack('Nlength', $this->_string_shift($payload)));
$this->errors[] = 'SSH_MSG_GLOBAL_REQUEST: ' . utf8_decode($this->_string_shift($payload, $length));
if (!$this->_send_binary_packet(pack('C', NET_SSH2_MSG_REQUEST_FAILURE))) {
return $this->_disconnect(NET_SSH2_DISCONNECT_BY_APPLICATION);
}
$payload = $this->_get_binary_packet();
break;
case NET_SSH2_MSG_CHANNEL_OPEN: // see http://tools.ietf.org/html/rfc4254#section-5.1
$this->_string_shift($payload, 1);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
extract(unpack('Nlength', $this->_string_shift($payload, 4)));
added phpseclib
2010-05-14 14:06:17 +00:00
$this->errors[] = 'SSH_MSG_CHANNEL_OPEN: ' . utf8_decode($this->_string_shift($payload, $length));
$this->_string_shift($payload, 4); // skip over client channel
extract(unpack('Nserver_channel', $this->_string_shift($payload, 4)));
$packet = pack('CN3a*Na*',
NET_SSH2_MSG_REQUEST_FAILURE, $server_channel, NET_SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED, 0, '', 0, '');
if (!$this->_send_binary_packet($packet)) {
return $this->_disconnect(NET_SSH2_DISCONNECT_BY_APPLICATION);
}
$payload = $this->_get_binary_packet();
break;
case NET_SSH2_MSG_CHANNEL_WINDOW_ADJUST:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->_string_shift($payload, 1);
extract(unpack('Nchannel', $this->_string_shift($payload, 4)));
extract(unpack('Nwindow_size', $this->_string_shift($payload, 4)));
$this->window_size_client_to_server[$channel]+= $window_size;
$payload = ($this->bitmap & NET_SSH2_MASK_WINDOW_ADJUST) ? true : $this->_get_binary_packet();
added phpseclib
2010-05-14 14:06:17 +00:00
}
}
return $payload;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Enable Quiet Mode
*
* Suppress stderr from output
*
* @access public
*/
function enableQuietMode()
{
$this->quiet_mode = true;
}
/**
* Disable Quiet Mode
*
* Show stderr in output
*
* @access public
*/
function disableQuietMode()
{
$this->quiet_mode = false;
}
/**
* Enable request-pty when using exec()
*
* @access public
*/
function enablePTY()
{
$this->request_pty = true;
}
/**
* Disable request-pty when using exec()
*
* @access public
*/
function disablePTY()
{
$this->request_pty = false;
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Gets channel data
*
* Returns the data as a string if it's available and false if not.
*
* @param $client_channel
* @return Mixed
* @access private
*/
new phpseclib
2011-05-19 18:02:11 +00:00
function _get_channel_packet($client_channel, $skip_extended = false)
added phpseclib
2010-05-14 14:06:17 +00:00
{
if (!empty($this->channel_buffers[$client_channel])) {
return array_shift($this->channel_buffers[$client_channel]);
}
while (true) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($this->curTimeout) {
if ($this->curTimeout < 0) {
$this->is_timeout = true;
return true;
}
$read = array($this->fsock);
$write = $except = null;
$start = strtok(microtime(), ' ') + strtok(''); // http://php.net/microtime#61838
$sec = floor($this->curTimeout);
$usec = 1000000 * ($this->curTimeout - $sec);
// on windows this returns a "Warning: Invalid CRT parameters detected" error
if (!@stream_select($read, $write, $except, $sec, $usec) && !count($read)) {
$this->is_timeout = true;
return true;
}
$elapsed = strtok(microtime(), ' ') + strtok('') - $start;
$this->curTimeout-= $elapsed;
}
added phpseclib
2010-05-14 14:06:17 +00:00
$response = $this->_get_binary_packet();
if ($response === false) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Connection closed by server');
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($client_channel == -1 && $response === true) {
return true;
}
if (!strlen($response)) {
new phpseclib
2011-05-19 18:02:11 +00:00
return '';
}
added phpseclib
2010-05-14 14:06:17 +00:00
extract(unpack('Ctype/Nchannel', $this->_string_shift($response, 5)));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->window_size_server_to_client[$channel]-= strlen($response) + 4;
// resize the window, if appropriate
if ($this->window_size_server_to_client[$channel] < 0) {
$packet = pack('CNN', NET_SSH2_MSG_CHANNEL_WINDOW_ADJUST, $this->server_channels[$channel], $this->window_size);
if (!$this->_send_binary_packet($packet)) {
return false;
}
$this->window_size_server_to_client[$channel]+= $this->window_size;
}
added phpseclib
2010-05-14 14:06:17 +00:00
switch ($this->channel_status[$channel]) {
case NET_SSH2_MSG_CHANNEL_OPEN:
switch ($type) {
case NET_SSH2_MSG_CHANNEL_OPEN_CONFIRMATION:
extract(unpack('Nserver_channel', $this->_string_shift($response, 4)));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->server_channels[$channel] = $server_channel;
extract(unpack('Nwindow_size', $this->_string_shift($response, 4)));
$this->window_size_client_to_server[$channel] = $window_size;
added phpseclib
2010-05-14 14:06:17 +00:00
$temp = unpack('Npacket_size_client_to_server', $this->_string_shift($response, 4));
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->packet_size_client_to_server[$channel] = $temp['packet_size_client_to_server'];
return $client_channel == $channel ? true : $this->_get_channel_packet($client_channel, $skip_extended);
added phpseclib
2010-05-14 14:06:17 +00:00
//case NET_SSH2_MSG_CHANNEL_OPEN_FAILURE:
default:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Unable to open channel');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_BY_APPLICATION);
}
break;
case NET_SSH2_MSG_CHANNEL_REQUEST:
switch ($type) {
case NET_SSH2_MSG_CHANNEL_SUCCESS:
return true;
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case NET_SSH2_MSG_CHANNEL_FAILURE:
return false;
added phpseclib
2010-05-14 14:06:17 +00:00
default:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Unable to fulfill channel request');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_BY_APPLICATION);
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
case NET_SSH2_MSG_CHANNEL_CLOSE:
return $type == NET_SSH2_MSG_CHANNEL_CLOSE ? true : $this->_get_channel_packet($client_channel, $skip_extended);
added phpseclib
2010-05-14 14:06:17 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// ie. $this->channel_status[$channel] == NET_SSH2_MSG_CHANNEL_DATA
added phpseclib
2010-05-14 14:06:17 +00:00
switch ($type) {
case NET_SSH2_MSG_CHANNEL_DATA:
new phpseclib
2011-05-19 18:02:11 +00:00
/*
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($channel == NET_SSH2_CHANNEL_EXEC) {
added phpseclib
2010-05-14 14:06:17 +00:00
// SCP requires null packets, such as this, be sent. further, in the case of the ssh.com SSH server
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
// this actually seems to make things twice as fast. more to the point, the message right after
added phpseclib
2010-05-14 14:06:17 +00:00
// SSH_MSG_CHANNEL_DATA (usually SSH_MSG_IGNORE) won't block for as long as it would have otherwise.
// in OpenSSH it slows things down but only by a couple thousandths of a second.
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->_send_channel_packet($channel, chr(0));
added phpseclib
2010-05-14 14:06:17 +00:00
}
new phpseclib
2011-05-19 18:02:11 +00:00
*/
added phpseclib
2010-05-14 14:06:17 +00:00
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$data = $this->_string_shift($response, $length);
if ($client_channel == $channel) {
return $data;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!isset($this->channel_buffers[$channel])) {
$this->channel_buffers[$channel] = array();
added phpseclib
2010-05-14 14:06:17 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->channel_buffers[$channel][] = $data;
added phpseclib
2010-05-14 14:06:17 +00:00
break;
case NET_SSH2_MSG_CHANNEL_EXTENDED_DATA:
new phpseclib
2011-05-19 18:02:11 +00:00
/*
added phpseclib
2010-05-14 14:06:17 +00:00
if ($client_channel == NET_SSH2_CHANNEL_EXEC) {
$this->_send_channel_packet($client_channel, chr(0));
}
new phpseclib
2011-05-19 18:02:11 +00:00
*/
added phpseclib
2010-05-14 14:06:17 +00:00
// currently, there's only one possible value for $data_type_code: NET_SSH2_EXTENDED_DATA_STDERR
extract(unpack('Ndata_type_code/Nlength', $this->_string_shift($response, 8)));
$data = $this->_string_shift($response, $length);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->stdErrorLog .= $data;
if ($skip_extended || $this->quiet_mode) {
break;
}
added phpseclib
2010-05-14 14:06:17 +00:00
if ($client_channel == $channel) {
return $data;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!isset($this->channel_buffers[$channel])) {
$this->channel_buffers[$channel] = array();
added phpseclib
2010-05-14 14:06:17 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->channel_buffers[$channel][] = $data;
added phpseclib
2010-05-14 14:06:17 +00:00
break;
case NET_SSH2_MSG_CHANNEL_REQUEST:
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$value = $this->_string_shift($response, $length);
switch ($value) {
case 'exit-signal':
$this->_string_shift($response, 1);
extract(unpack('Nlength', $this->_string_shift($response, 4)));
$this->errors[] = 'SSH_MSG_CHANNEL_REQUEST (exit-signal): ' . $this->_string_shift($response, $length);
$this->_string_shift($response, 1);
extract(unpack('Nlength', $this->_string_shift($response, 4)));
if ($length) {
$this->errors[count($this->errors)].= "\r\n" . $this->_string_shift($response, $length);
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->_send_binary_packet(pack('CN', NET_SSH2_MSG_CHANNEL_EOF, $this->server_channels[$client_channel]));
$this->_send_binary_packet(pack('CN', NET_SSH2_MSG_CHANNEL_CLOSE, $this->server_channels[$channel]));
$this->channel_status[$channel] = NET_SSH2_MSG_CHANNEL_EOF;
break;
case 'exit-status':
extract(unpack('Cfalse/Nexit_status', $this->_string_shift($response, 5)));
$this->exit_status = $exit_status;
// "The client MAY ignore these messages."
// -- http://tools.ietf.org/html/rfc4254#section-6.10
break;
added phpseclib
2010-05-14 14:06:17 +00:00
default:
// "Some systems may not implement signals, in which case they SHOULD ignore this message."
// -- http://tools.ietf.org/html/rfc4254#section-6.9
break;
}
break;
case NET_SSH2_MSG_CHANNEL_CLOSE:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->curTimeout = 0;
if ($this->bitmap & NET_SSH2_MASK_SHELL) {
$this->bitmap&= ~NET_SSH2_MASK_SHELL;
}
if ($this->channel_status[$channel] != NET_SSH2_MSG_CHANNEL_EOF) {
$this->_send_binary_packet(pack('CN', NET_SSH2_MSG_CHANNEL_CLOSE, $this->server_channels[$channel]));
}
$this->channel_status[$channel] = NET_SSH2_MSG_CHANNEL_CLOSE;
added phpseclib
2010-05-14 14:06:17 +00:00
return true;
case NET_SSH2_MSG_CHANNEL_EOF:
break;
default:
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Error reading channel data');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_BY_APPLICATION);
}
}
}
/**
* Sends Binary Packets
*
* See '6. Binary Packet Protocol' of rfc4253 for more info.
*
* @param String $data
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* @param optional String $logged
added phpseclib
2010-05-14 14:06:17 +00:00
* @see Net_SSH2::_get_binary_packet()
* @return Boolean
* @access private
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
function _send_binary_packet($data, $logged = null)
added phpseclib
2010-05-14 14:06:17 +00:00
{
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (!is_resource($this->fsock) || feof($this->fsock)) {
user_error('Connection closed prematurely');
$this->bitmap = 0;
added phpseclib
2010-05-14 14:06:17 +00:00
return false;
}
//if ($this->compress) {
// // the -4 removes the checksum:
// // http://php.net/function.gzcompress#57710
// $data = substr(gzcompress($data), 0, -4);
//}
// 4 (packet length) + 1 (padding length) + 4 (minimal padding amount) == 9
$packet_length = strlen($data) + 9;
// round up to the nearest $this->encrypt_block_size
$packet_length+= (($this->encrypt_block_size - 1) * $packet_length) % $this->encrypt_block_size;
// subtracting strlen($data) is obvious - subtracting 5 is necessary because of packet_length and padding_length
$padding_length = $packet_length - strlen($data) - 5;
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$padding = crypt_random_string($padding_length);
added phpseclib
2010-05-14 14:06:17 +00:00
// we subtract 4 from packet_length because the packet_length field isn't supposed to include itself
$packet = pack('NCa*', $packet_length - 4, $padding_length, $data . $padding);
$hmac = $this->hmac_create !== false ? $this->hmac_create->hash(pack('Na*', $this->send_seq_no, $packet)) : '';
$this->send_seq_no++;
if ($this->encrypt !== false) {
$packet = $this->encrypt->encrypt($packet);
}
$packet.= $hmac;
$start = strtok(microtime(), ' ') + strtok(''); // http://php.net/microtime#61838
$result = strlen($packet) == fputs($this->fsock, $packet);
$stop = strtok(microtime(), ' ') + strtok('');
if (defined('NET_SSH2_LOGGING')) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$current = strtok(microtime(), ' ') + strtok('');
$message_number = isset($this->message_numbers[ord($data[0])]) ? $this->message_numbers[ord($data[0])] : 'UNKNOWN (' . ord($data[0]) . ')';
$message_number = '-> ' . $message_number .
' (since last: ' . round($current - $this->last_packet, 4) . ', network: ' . round($stop - $start, 4) . 's)';
$this->_append_log($message_number, isset($logged) ? $logged : $data);
$this->last_packet = $current;
added phpseclib
2010-05-14 14:06:17 +00:00
}
return $result;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Logs data packets
*
* Makes sure that only the last 1MB worth of packets will be logged
*
* @param String $data
* @access private
*/
function _append_log($message_number, $message)
{
// remove the byte identifying the message type from all but the first two messages (ie. the identification strings)
if (strlen($message_number) > 2) {
$this->_string_shift($message);
}
switch (NET_SSH2_LOGGING) {
// useful for benchmarks
case NET_SSH2_LOG_SIMPLE:
$this->message_number_log[] = $message_number;
break;
// the most useful log for SSH2
case NET_SSH2_LOG_COMPLEX:
$this->message_number_log[] = $message_number;
$this->log_size+= strlen($message);
$this->message_log[] = $message;
while ($this->log_size > NET_SSH2_LOG_MAX_SIZE) {
$this->log_size-= strlen(array_shift($this->message_log));
array_shift($this->message_number_log);
}
break;
// dump the output out realtime; packets may be interspersed with non packets,
// passwords won't be filtered out and select other packets may not be correctly
// identified
case NET_SSH2_LOG_REALTIME:
switch (PHP_SAPI) {
case 'cli':
$start = $stop = "\r\n";
break;
default:
$start = '<pre>';
$stop = '</pre>';
}
echo $start . $this->_format_log(array($message), array($message_number)) . $stop;
@flush();
@ob_flush();
break;
// basically the same thing as NET_SSH2_LOG_REALTIME with the caveat that NET_SSH2_LOG_REALTIME_FILE
// needs to be defined and that the resultant log file will be capped out at NET_SSH2_LOG_MAX_SIZE.
// the earliest part of the log file is denoted by the first <<< START >>> and is not going to necessarily
// at the beginning of the file
case NET_SSH2_LOG_REALTIME_FILE:
if (!isset($this->realtime_log_file)) {
// PHP doesn't seem to like using constants in fopen()
$filename = NET_SSH2_LOG_REALTIME_FILENAME;
$fp = fopen($filename, 'w');
$this->realtime_log_file = $fp;
}
if (!is_resource($this->realtime_log_file)) {
break;
}
$entry = $this->_format_log(array($message), array($message_number));
if ($this->realtime_log_wrap) {
$temp = "<<< START >>>\r\n";
$entry.= $temp;
fseek($this->realtime_log_file, ftell($this->realtime_log_file) - strlen($temp));
}
$this->realtime_log_size+= strlen($entry);
if ($this->realtime_log_size > NET_SSH2_LOG_MAX_SIZE) {
fseek($this->realtime_log_file, 0);
$this->realtime_log_size = strlen($entry);
$this->realtime_log_wrap = true;
}
fputs($this->realtime_log_file, $entry);
}
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Sends channel data
*
* Spans multiple SSH_MSG_CHANNEL_DATAs if appropriate
*
* @param Integer $client_channel
* @param String $data
* @return Boolean
* @access private
*/
function _send_channel_packet($client_channel, $data)
{
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/* The maximum amount of data allowed is determined by the maximum
packet size for the channel, and the current window size, whichever
is smaller.
-- http://tools.ietf.org/html/rfc4254#section-5.2 */
$max_size = min(
$this->packet_size_client_to_server[$client_channel],
$this->window_size_client_to_server[$client_channel]
) - 4;
while (strlen($data) > $max_size) {
if (!$this->window_size_client_to_server[$client_channel]) {
$this->bitmap^= NET_SSH2_MASK_WINDOW_ADJUST;
// using an invalid channel will let the buffers be built up for the valid channels
$output = $this->_get_channel_packet(-1);
$this->bitmap^= NET_SSH2_MASK_WINDOW_ADJUST;
$max_size = min(
$this->packet_size_client_to_server[$client_channel],
$this->window_size_client_to_server[$client_channel]
) - 4;
added phpseclib
2010-05-14 14:06:17 +00:00
}
$packet = pack('CN2a*',
NET_SSH2_MSG_CHANNEL_DATA,
$this->server_channels[$client_channel],
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$max_size,
$this->_string_shift($data, $max_size)
added phpseclib
2010-05-14 14:06:17 +00:00
);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->window_size_client_to_server[$client_channel]-= $max_size + 4;
added phpseclib
2010-05-14 14:06:17 +00:00
if (!$this->_send_binary_packet($packet)) {
return false;
}
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (strlen($data) >= $this->window_size_client_to_server[$client_channel] - 4) {
$this->bitmap^= NET_SSH2_MASK_WINDOW_ADJUST;
$this->_get_channel_packet(-1);
$this->bitmap^= NET_SSH2_MASK_WINDOW_ADJUST;
added phpseclib
2010-05-14 14:06:17 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->window_size_client_to_server[$client_channel]-= strlen($data) + 4;
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_send_binary_packet(pack('CN2a*',
NET_SSH2_MSG_CHANNEL_DATA,
$this->server_channels[$client_channel],
strlen($data),
$data));
}
new phpseclib
2011-05-19 18:02:11 +00:00
/**
* Closes and flushes a channel
*
* Net_SSH2 doesn't properly close most channels. For exec() channels are normally closed by the server
* and for SFTP channels are presumably closed when the client disconnects. This functions is intended
* for SCP more than anything.
*
* @param Integer $client_channel
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
* @param Boolean $want_reply
new phpseclib
2011-05-19 18:02:11 +00:00
* @return Boolean
* @access private
*/
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
function _close_channel($client_channel, $want_reply = false)
new phpseclib
2011-05-19 18:02:11 +00:00
{
// see http://tools.ietf.org/html/rfc4254#section-5.3
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$this->_send_binary_packet(pack('CN', NET_SSH2_MSG_CHANNEL_EOF, $this->server_channels[$client_channel]));
if (!$want_reply) {
$this->_send_binary_packet(pack('CN', NET_SSH2_MSG_CHANNEL_CLOSE, $this->server_channels[$client_channel]));
}
$this->channel_status[$client_channel] = NET_SSH2_MSG_CHANNEL_CLOSE;
$this->curTimeout = 0;
while (!is_bool($this->_get_channel_packet($client_channel)));
if ($want_reply) {
$this->_send_binary_packet(pack('CN', NET_SSH2_MSG_CHANNEL_CLOSE, $this->server_channels[$client_channel]));
new phpseclib
2011-05-19 18:02:11 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($this->bitmap & NET_SSH2_MASK_SHELL) {
$this->bitmap&= ~NET_SSH2_MASK_SHELL;
}
new phpseclib
2011-05-19 18:02:11 +00:00
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Disconnect
*
* @param Integer $reason
* @return Boolean
* @access private
*/
function _disconnect($reason)
{
if ($this->bitmap) {
$data = pack('CNNa*Na*', NET_SSH2_MSG_DISCONNECT, $reason, 0, '', 0, '');
$this->_send_binary_packet($data);
$this->bitmap = 0;
fclose($this->fsock);
return false;
}
}
/**
* String Shift
*
* Inspired by array_shift
*
* @param String $string
* @param optional Integer $index
* @return String
* @access private
*/
function _string_shift(&$string, $index = 1)
{
$substr = substr($string, 0, $index);
$string = substr($string, $index);
return $substr;
}
/**
* Define Array
*
* Takes any number of arrays whose indices are integers and whose values are strings and defines a bunch of
* named constants from it, using the value as the name of the constant and the index as the value of the constant.
* If any of the constants that would be defined already exists, none of the constants will be defined.
*
* @param Array $array
* @access private
*/
function _define_array()
{
$args = func_get_args();
foreach ($args as $arg) {
foreach ($arg as $key=>$value) {
if (!defined($value)) {
define($value, $key);
} else {
break 2;
}
}
}
}
/**
* Returns a log of the packets that have been sent and received.
*
* Returns a string if NET_SSH2_LOGGING == NET_SSH2_LOG_COMPLEX, an array if NET_SSH2_LOGGING == NET_SSH2_LOG_SIMPLE and false if !defined('NET_SSH2_LOGGING')
*
* @access public
* @return String or Array
*/
function getLog()
{
if (!defined('NET_SSH2_LOGGING')) {
return false;
}
switch (NET_SSH2_LOGGING) {
case NET_SSH2_LOG_SIMPLE:
return $this->message_number_log;
break;
case NET_SSH2_LOG_COMPLEX:
return $this->_format_log($this->message_log, $this->message_number_log);
break;
default:
return false;
}
}
/**
* Formats a log for printing
*
* @param Array $message_log
* @param Array $message_number_log
* @access private
* @return String
*/
function _format_log($message_log, $message_number_log)
{
$output = '';
for ($i = 0; $i < count($message_log); $i++) {
$output.= $message_number_log[$i] . "\r\n";
$current_log = $message_log[$i];
$j = 0;
do {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if (strlen($current_log)) {
added phpseclib
2010-05-14 14:06:17 +00:00
$output.= str_pad(dechex($j), 7, '0', STR_PAD_LEFT) . '0 ';
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$fragment = $this->_string_shift($current_log, $this->log_short_width);
$hex = substr(preg_replace_callback('#.#s', array($this, '_format_log_helper'), $fragment), strlen($this->log_boundary));
added phpseclib
2010-05-14 14:06:17 +00:00
// replace non ASCII printable characters with dots
// http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters
// also replace < with a . since < messes up the output on web browsers
$raw = preg_replace('#[^\x20-\x7E]|<#', '.', $fragment);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$output.= str_pad($hex, $this->log_long_width - $this->log_short_width, ' ') . $raw . "\r\n";
added phpseclib
2010-05-14 14:06:17 +00:00
$j++;
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
} while (strlen($current_log));
added phpseclib
2010-05-14 14:06:17 +00:00
$output.= "\r\n";
}
return $output;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Helper function for _format_log
*
* For use with preg_replace_callback()
*
* @param Array $matches
* @access private
* @return String
*/
function _format_log_helper($matches)
{
return $this->log_boundary . str_pad(dechex(ord($matches[0])), 2, '0', STR_PAD_LEFT);
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Returns all errors
*
* @return String
* @access public
*/
function getErrors()
{
return $this->errors;
}
/**
* Returns the last error
*
* @return String
* @access public
*/
function getLastError()
{
return $this->errors[count($this->errors) - 1];
}
/**
* Return the server identification.
*
* @return String
* @access public
*/
function getServerIdentification()
{
return $this->server_identifier;
}
/**
* Return a list of the key exchange algorithms the server supports.
*
* @return Array
* @access public
*/
function getKexAlgorithms()
{
return $this->kex_algorithms;
}
/**
* Return a list of the host key (public key) algorithms the server supports.
*
* @return Array
* @access public
*/
function getServerHostKeyAlgorithms()
{
return $this->server_host_key_algorithms;
}
/**
* Return a list of the (symmetric key) encryption algorithms the server supports, when receiving stuff from the client.
*
* @return Array
* @access public
*/
function getEncryptionAlgorithmsClient2Server()
{
return $this->encryption_algorithms_client_to_server;
}
/**
* Return a list of the (symmetric key) encryption algorithms the server supports, when sending stuff to the client.
*
* @return Array
* @access public
*/
function getEncryptionAlgorithmsServer2Client()
{
return $this->encryption_algorithms_server_to_client;
}
/**
* Return a list of the MAC algorithms the server supports, when receiving stuff from the client.
*
* @return Array
* @access public
*/
function getMACAlgorithmsClient2Server()
{
return $this->mac_algorithms_client_to_server;
}
/**
* Return a list of the MAC algorithms the server supports, when sending stuff to the client.
*
* @return Array
* @access public
*/
function getMACAlgorithmsServer2Client()
{
return $this->mac_algorithms_server_to_client;
}
/**
* Return a list of the compression algorithms the server supports, when receiving stuff from the client.
*
* @return Array
* @access public
*/
function getCompressionAlgorithmsClient2Server()
{
return $this->compression_algorithms_client_to_server;
}
/**
* Return a list of the compression algorithms the server supports, when sending stuff to the client.
*
* @return Array
* @access public
*/
function getCompressionAlgorithmsServer2Client()
{
return $this->compression_algorithms_server_to_client;
}
/**
* Return a list of the languages the server supports, when sending stuff to the client.
*
* @return Array
* @access public
*/
function getLanguagesServer2Client()
{
return $this->languages_server_to_client;
}
/**
* Return a list of the languages the server supports, when receiving stuff from the client.
*
* @return Array
* @access public
*/
function getLanguagesClient2Server()
{
return $this->languages_client_to_server;
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Returns the banner message.
*
* Quoting from the RFC, "in some jurisdictions, sending a warning message before
* authentication may be relevant for getting legal protection."
*
* @return String
* @access public
*/
function getBannerMessage()
{
return $this->banner_message;
}
added phpseclib
2010-05-14 14:06:17 +00:00
/**
* Returns the server public host key.
*
* Caching this the first time you connect to a server and checking the result on subsequent connections
* is recommended. Returns false if the server signature is not signed correctly with the public host key.
*
* @return Mixed
* @access public
*/
function getServerPublicHostKey()
{
$signature = $this->signature;
$server_public_host_key = $this->server_public_host_key;
extract(unpack('Nlength', $this->_string_shift($server_public_host_key, 4)));
$this->_string_shift($server_public_host_key, $length);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
if ($this->signature_validated) {
return $this->bitmap ?
$this->signature_format . ' ' . base64_encode($this->server_public_host_key) :
false;
}
$this->signature_validated = true;
added phpseclib
2010-05-14 14:06:17 +00:00
switch ($this->signature_format) {
case 'ssh-dss':
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
$zero = new Math_BigInteger();
added phpseclib
2010-05-14 14:06:17 +00:00
$temp = unpack('Nlength', $this->_string_shift($server_public_host_key, 4));
$p = new Math_BigInteger($this->_string_shift($server_public_host_key, $temp['length']), -256);
$temp = unpack('Nlength', $this->_string_shift($server_public_host_key, 4));
$q = new Math_BigInteger($this->_string_shift($server_public_host_key, $temp['length']), -256);
$temp = unpack('Nlength', $this->_string_shift($server_public_host_key, 4));
$g = new Math_BigInteger($this->_string_shift($server_public_host_key, $temp['length']), -256);
$temp = unpack('Nlength', $this->_string_shift($server_public_host_key, 4));
$y = new Math_BigInteger($this->_string_shift($server_public_host_key, $temp['length']), -256);
/* The value for 'dss_signature_blob' is encoded as a string containing
r, followed by s (which are 160-bit integers, without lengths or
padding, unsigned, and in network byte order). */
$temp = unpack('Nlength', $this->_string_shift($signature, 4));
if ($temp['length'] != 40) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Invalid signature');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
$r = new Math_BigInteger($this->_string_shift($signature, 20), 256);
$s = new Math_BigInteger($this->_string_shift($signature, 20), 256);
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
switch (true) {
case $r->equals($zero):
case $r->compare($q) >= 0:
case $s->equals($zero):
case $s->compare($q) >= 0:
user_error('Invalid signature');
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
added phpseclib
2010-05-14 14:06:17 +00:00
}
$w = $s->modInverse($q);
new phpseclib
2011-05-19 18:02:11 +00:00
$u1 = $w->multiply(new Math_BigInteger(sha1($this->exchange_hash), 16));
added phpseclib
2010-05-14 14:06:17 +00:00
list(, $u1) = $u1->divide($q);
$u2 = $w->multiply($r);
list(, $u2) = $u2->divide($q);
$g = $g->modPow($u1, $p);
$y = $y->modPow($u2, $p);
$v = $g->multiply($y);
list(, $v) = $v->divide($p);
list(, $v) = $v->divide($q);
if (!$v->equals($r)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Bad server signature');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE);
}
break;
case 'ssh-rsa':
$temp = unpack('Nlength', $this->_string_shift($server_public_host_key, 4));
$e = new Math_BigInteger($this->_string_shift($server_public_host_key, $temp['length']), -256);
$temp = unpack('Nlength', $this->_string_shift($server_public_host_key, 4));
$n = new Math_BigInteger($this->_string_shift($server_public_host_key, $temp['length']), -256);
$nLength = $temp['length'];
/*
$temp = unpack('Nlength', $this->_string_shift($signature, 4));
$signature = $this->_string_shift($signature, $temp['length']);
if (!class_exists('Crypt_RSA')) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
include_once 'Crypt/RSA.php';
added phpseclib
2010-05-14 14:06:17 +00:00
}
$rsa = new Crypt_RSA();
$rsa->setSignatureMode(CRYPT_RSA_SIGNATURE_PKCS1);
$rsa->loadKey(array('e' => $e, 'n' => $n), CRYPT_RSA_PUBLIC_FORMAT_RAW);
new phpseclib
2011-05-19 18:02:11 +00:00
if (!$rsa->verify($this->exchange_hash, $signature)) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Bad server signature');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE);
}
*/
$temp = unpack('Nlength', $this->_string_shift($signature, 4));
$s = new Math_BigInteger($this->_string_shift($signature, $temp['length']), 256);
// validate an RSA signature per "8.2 RSASSA-PKCS1-v1_5", "5.2.2 RSAVP1", and "9.1 EMSA-PSS" in the
// following URL:
// ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1.pdf
// also, see SSHRSA.c (rsa2_verifysig) in PuTTy's source.
if ($s->compare(new Math_BigInteger()) < 0 || $s->compare($n->subtract(new Math_BigInteger(1))) > 0) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Invalid signature');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);
}
$s = $s->modPow($e, $n);
$s = $s->toBytes();
new phpseclib
2011-05-19 18:02:11 +00:00
$h = pack('N4H*', 0x00302130, 0x0906052B, 0x0E03021A, 0x05000414, sha1($this->exchange_hash));
added phpseclib
2010-05-14 14:06:17 +00:00
$h = chr(0x01) . str_repeat(chr(0xFF), $nLength - 3 - strlen($h)) . $h;
if ($s != $h) {
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
user_error('Bad server signature');
added phpseclib
2010-05-14 14:06:17 +00:00
return $this->_disconnect(NET_SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE);
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
break;
default:
user_error('Unsupported signature format');
return $this->_disconnect(NET_SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE);
}
return $this->signature_format . ' ' . base64_encode($this->server_public_host_key);
}
/**
* Returns the exit status of an SSH command or false.
*
* @return Integer or false
* @access public
*/
function getExitStatus()
{
if (is_null($this->exit_status)) {
return false;
added phpseclib
2010-05-14 14:06:17 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
return $this->exit_status;
}
added phpseclib
2010-05-14 14:06:17 +00:00
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
/**
* Is a path includable?
*
* @return Boolean
* @access private
*/
function _is_includable($suffix)
{
// stream_resolve_include_path was introduced in PHP 5.3.2
if (function_exists('stream_resolve_include_path')) {
return stream_resolve_include_path($suffix) !== false;
}
$paths = PATH_SEPARATOR == ':' ?
preg_split('#(?<!phar):#', get_include_path()) :
explode(PATH_SEPARATOR, get_include_path());
foreach ($paths as $prefix) {
$ds = substr($prefix, -1) == DIRECTORY_SEPARATOR ? '' : DIRECTORY_SEPARATOR;
$file = $prefix . $ds . $suffix;
if (file_exists($file)) {
return true;
}
}
return false;
added phpseclib
2010-05-14 14:06:17 +00:00
}
updated to phpseclib 0.3.6
2014-03-30 06:55:33 +00:00
}