PageRenderTime 63ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

/drupal/profiles/medienlabor/modules/contrib/aes/phpseclib/Net/SSH2.php

https://bitbucket.org/cbeier/test
PHP | 2901 lines | 1538 code | 348 blank | 1015 comment | 253 complexity | 96d43c659ee7f81da4d0b1a7ce4d3886 MD5 | raw file
Possible License(s): GPL-2.0, AGPL-1.0, LGPL-2.1

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

    

  1. <?php

    2. 

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

    3. 

  3. 

    4. 

  4. /**

    5. 

  5.  * Pure-PHP implementation of SSHv2.

    6. 

  6.  *

    7. 

  7.  * PHP versions 4 and 5

    8. 

  8.  *

    9. 

  9.  * Here are some examples of how to use this library:

    10. 

  10.  * <code>

    11. 

  11.  * <?php

    12. 

  12.  *    include('Net/SSH2.php');

    13. 

  13.  *

    14. 

  14.  *    $ssh = new Net_SSH2('www.domain.tld');

    15. 

  15.  *    if (!$ssh->login('username', 'password')) {

    16. 

  16.  *        exit('Login Failed');

    17. 

  17.  *    }

    18. 

  18.  *

    19. 

  19.  *    echo $ssh->exec('pwd');

    20. 

  20.  *    echo $ssh->exec('ls -la');

    21. 

  21.  * ?>

    22. 

  22.  * </code>

    23. 

  23.  *

    24. 

  24.  * <code>

    25. 

  25.  * <?php

    26. 

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

    27. 

  27.  *    include('Net/SSH2.php');

    28. 

  28.  *

    29. 

  29.  *    $key = new Crypt_RSA();

    30. 

  30.  *    //$key->setPassword('whatever');

    31. 

  31.  *    $key->loadKey(file_get_contents('privatekey'));

    32. 

  32.  *

    33. 

  33.  *    $ssh = new Net_SSH2('www.domain.tld');

    34. 

  34.  *    if (!$ssh->login('username', $key)) {

    35. 

  35.  *        exit('Login Failed');

    36. 

  36.  *    }

    37. 

  37.  *

    38. 

  38.  *    echo $ssh->read('username@username:~$');

    39. 

  39.  *    $ssh->write("ls -la\n");

    40. 

  40.  *    echo $ssh->read('username@username:~$');

    41. 

  41.  * ?>

    42. 

  42.  * </code>

    43. 

  43.  *

    44. 

  44.  * LICENSE: Permission is hereby granted, free of charge, to any person obtaining a copy

    45. 

  45.  * of this software and associated documentation files (the "Software"), to deal

    46. 

  46.  * in the Software without restriction, including without limitation the rights

    47. 

  47.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

    48. 

  48.  * copies of the Software, and to permit persons to whom the Software is

    49. 

  49.  * furnished to do so, subject to the following conditions:

    50. 

  50.  * 

    51. 

  51.  * The above copyright notice and this permission notice shall be included in

    52. 

  52.  * all copies or substantial portions of the Software.

    53. 

  53.  * 

    54. 

  54.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    55. 

  55.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    56. 

  56.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    57. 

  57.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    58. 

  58.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    59. 

  59.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

    60. 

  60.  * THE SOFTWARE.

    61. 

  61.  *

    62. 

  62.  * @category   Net

    63. 

  63.  * @package    Net_SSH2

    64. 

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

    65. 

  65.  * @copyright  MMVII Jim Wigginton

    66. 

  66.  * @license    http://www.opensource.org/licenses/mit-license.html  MIT License

    67. 

  67.  * @version    $Id: SSH2.php,v 1.53 2010-10-24 01:24:30 terrafrost Exp $

    68. 

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

    69. 

  69.  */

    70. 

  70. 

    71. 

  71. /**

    72. 

  72.  * Include Math_BigInteger

    73. 

  73.  *

    74. 

  74.  * Used to do Diffie-Hellman key exchange and DSA/RSA signature verification.

    75. 

  75.  */

    76. 

  76. if (!class_exists('Math_BigInteger')) {

    77. 

  77.     require_once('Math/BigInteger.php');

    78. 

  78. }

    79. 

  79. 

    80. 

  80. /**

    81. 

  81.  * Include Crypt_Random

    82. 

  82.  */

    83. 

  83. // the class_exists() will only be called if the crypt_random function hasn't been defined and

    84. 

  84. // will trigger a call to __autoload() if you're wanting to auto-load classes

    85. 

  85. // call function_exists() a second time to stop the require_once from being called outside

    86. 

  86. // of the auto loader

    87. 

  87. if (!function_exists('crypt_random') && !class_exists('Crypt_Random') && !function_exists('crypt_random')) {

    88. 

  88.     require_once('Crypt/Random.php');

    89. 

  89. }

    90. 

  90. 

    91. 

  91. /**

    92. 

  92.  * Include Crypt_Hash

    93. 

  93.  */

    94. 

  94. if (!class_exists('Crypt_Hash')) {

    95. 

  95.     require_once('Crypt/Hash.php');

    96. 

  96. }

    97. 

  97. 

    98. 

  98. /**

    99. 

  99.  * Include Crypt_TripleDES

    100. 

  100.  */

    101. 

  101. if (!class_exists('Crypt_TripleDES')) {

    102. 

  102.     require_once('Crypt/TripleDES.php');

    103. 

  103. }

    104. 

  104. 

    105. 

  105. /**

    106. 

  106.  * Include Crypt_RC4

    107. 

  107.  */

    108. 

  108. if (!class_exists('Crypt_RC4')) {

    109. 

  109.     require_once('Crypt/RC4.php');

    110. 

  110. }

    111. 

  111. 

    112. 

  112. /**

    113. 

  113.  * Include Crypt_AES

    114. 

  114.  */

    115. 

  115. if (!class_exists('Crypt_AES')) {

    116. 

  116.     require_once('Crypt/AES.php');

    117. 

  117. }

    118. 

  118. 

    119. 

  119. /**#@+

    120. 

  120.  * Execution Bitmap Masks

    121. 

  121.  *

    122. 

  122.  * @see Net_SSH2::bitmap

    123. 

  123.  * @access private

    124. 

  124.  */

    125. 

  125. define('NET_SSH2_MASK_CONSTRUCTOR', 0x00000001);

    126. 

  126. define('NET_SSH2_MASK_LOGIN',       0x00000002);

    127. 

  127. define('NET_SSH2_MASK_SHELL',       0x00000004);

    128. 

  128. /**#@-*/

    129. 

  129. 

    130. 

  130. /**#@+

    131. 

  131.  * Channel constants

    132. 

  132.  *

    133. 

  133.  * RFC4254 refers not to client and server channels but rather to sender and recipient channels.  we don't refer

    134. 

  134.  * to them in that way because RFC4254 toggles the meaning. the client sends a SSH_MSG_CHANNEL_OPEN message with

    135. 

  135.  * a sender channel and the server sends a SSH_MSG_CHANNEL_OPEN_CONFIRMATION in response, with a sender and a

    136. 

  136.  * recepient channel.  at first glance, you might conclude that SSH_MSG_CHANNEL_OPEN_CONFIRMATION's sender channel

    137. 

  137.  * would be the same thing as SSH_MSG_CHANNEL_OPEN's sender channel, but it's not, per this snipet:

    138. 

  138.  *     The 'recipient channel' is the channel number given in the original

    139. 

  139.  *     open request, and 'sender channel' is the channel number allocated by

    140. 

  140.  *     the other side.

    141. 

  141.  *

    142. 

  142.  * @see Net_SSH2::_send_channel_packet()

    143. 

  143.  * @see Net_SSH2::_get_channel_packet()

    144. 

  144.  * @access private

    145. 

  145.  */

    146. 

  146. define('NET_SSH2_CHANNEL_EXEC', 0); // PuTTy uses 0x100

    147. 

  147. define('NET_SSH2_CHANNEL_SHELL',1);

    148. 

  148. /**#@-*/

    149. 

  149. 

    150. 

  150. /**#@+

    151. 

  151.  * @access public

    152. 

  152.  * @see Net_SSH2::getLog()

    153. 

  153.  */

    154. 

  154. /**

    155. 

  155.  * Returns the message numbers

    156. 

  156.  */

    157. 

  157. define('NET_SSH2_LOG_SIMPLE',  1);

    158. 

  158. /**

    159. 

  159.  * Returns the message content

    160. 

  160.  */

    161. 

  161. define('NET_SSH2_LOG_COMPLEX', 2);

    162. 

  162. /**

    163. 

  163.  * Outputs the content real-time

    164. 

  164.  */

    165. 

  165. define('NET_SSH2_LOG_REALTIME', 3);

    166. 

  166. /**#@-*/

    167. 

  167. 

    168. 

  168. /**#@+

    169. 

  169.  * @access public

    170. 

  170.  * @see Net_SSH2::read()

    171. 

  171.  */

    172. 

  172. /**

    173. 

  173.  * Returns when a string matching $expect exactly is found

    174. 

  174.  */

    175. 

  175. define('NET_SSH2_READ_SIMPLE',  1);

    176. 

  176. /**

    177. 

  177.  * Returns when a string matching the regular expression $expect is found

    178. 

  178.  */

    179. 

  179. define('NET_SSH2_READ_REGEX', 2);

    180. 

  180. /**

    181. 

  181.  * Make sure that the log never gets larger than this

    182. 

  182.  */

    183. 

  183. define('NET_SSH2_LOG_MAX_SIZE', 1024 * 1024);

    184. 

  184. /**#@-*/

    185. 

  185. 

    186. 

  186. /**

    187. 

  187.  * Pure-PHP implementation of SSHv2.

    188. 

  188.  *

    189. 

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

    190. 

  190.  * @version 0.1.0

    191. 

  191.  * @access  public

    192. 

  192.  * @package Net_SSH2

    193. 

  193.  */

    194. 

  194. class Net_SSH2 {

    195. 

  195.     /**

    196. 

  196.      * The SSH identifier

    197. 

  197.      *

    198. 

  198.      * @var String

    199. 

  199.      * @access private

    200. 

  200.      */

    201. 

  201.     var $identifier = 'SSH-2.0-phpseclib_0.3';

    202. 

  202. 

    203. 

  203.     /**

    204. 

  204.      * The Socket Object

    205. 

  205.      *

    206. 

  206.      * @var Object

    207. 

  207.      * @access private

    208. 

  208.      */

    209. 

  209.     var $fsock;

    210. 

  210. 

    211. 

  211.     /**

    212. 

  212.      * Execution Bitmap

    213. 

  213.      *

    214. 

  214.      * The bits that are set reprsent functions that have been called already.  This is used to determine

    215. 

  215.      * if a requisite function has been successfully executed.  If not, an error should be thrown.

    216. 

  216.      *

    217. 

  217.      * @var Integer

    218. 

  218.      * @access private

    219. 

  219.      */

    220. 

  220.     var $bitmap = 0;

    221. 

  221. 

    222. 

  222.     /**

    223. 

  223.      * Error information

    224. 

  224.      *

    225. 

  225.      * @see Net_SSH2::getErrors()

    226. 

  226.      * @see Net_SSH2::getLastError()

    227. 

  227.      * @var String

    228. 

  228.      * @access private

    229. 

  229.      */

    230. 

  230.     var $errors = array();

    231. 

  231. 

    232. 

  232.     /**

    233. 

  233.      * Server Identifier

    234. 

  234.      *

    235. 

  235.      * @see Net_SSH2::getServerIdentification()

    236. 

  236.      * @var String

    237. 

  237.      * @access private

    238. 

  238.      */

    239. 

  239.     var $server_identifier = '';

    240. 

  240. 

    241. 

  241.     /**

    242. 

  242.      * Key Exchange Algorithms

    243. 

  243.      *

    244. 

  244.      * @see Net_SSH2::getKexAlgorithims()

    245. 

  245.      * @var Array

    246. 

  246.      * @access private

    247. 

  247.      */

    248. 

  248.     var $kex_algorithms;

    249. 

  249. 

    250. 

  250.     /**

    251. 

  251.      * Server Host Key Algorithms

    252. 

  252.      *

    253. 

  253.      * @see Net_SSH2::getServerHostKeyAlgorithms()

    254. 

  254.      * @var Array

    255. 

  255.      * @access private

    256. 

  256.      */

    257. 

  257.     var $server_host_key_algorithms;

    258. 

  258. 

    259. 

  259.     /**

    260. 

  260.      * Encryption Algorithms: Client to Server

    261. 

  261.      *

    262. 

  262.      * @see Net_SSH2::getEncryptionAlgorithmsClient2Server()

    263. 

  263.      * @var Array

    264. 

  264.      * @access private

    265. 

  265.      */

    266. 

  266.     var $encryption_algorithms_client_to_server;

    267. 

  267. 

    268. 

  268.     /**

    269. 

  269.      * Encryption Algorithms: Server to Client

    270. 

  270.      *

    271. 

  271.      * @see Net_SSH2::getEncryptionAlgorithmsServer2Client()

    272. 

  272.      * @var Array

    273. 

  273.      * @access private

    274. 

  274.      */

    275. 

  275.     var $encryption_algorithms_server_to_client;

    276. 

  276. 

    277. 

  277.     /**

    278. 

  278.      * MAC Algorithms: Client to Server

    279. 

  279.      *

    280. 

  280.      * @see Net_SSH2::getMACAlgorithmsClient2Server()

    281. 

  281.      * @var Array

    282. 

  282.      * @access private

    283. 

  283.      */

    284. 

  284.     var $mac_algorithms_client_to_server;

    285. 

  285. 

    286. 

  286.     /**

    287. 

  287.      * MAC Algorithms: Server to Client

    288. 

  288.      *

    289. 

  289.      * @see Net_SSH2::getMACAlgorithmsServer2Client()

    290. 

  290.      * @var Array

    291. 

  291.      * @access private

    292. 

  292.      */

    293. 

  293.     var $mac_algorithms_server_to_client;

    294. 

  294. 

    295. 

  295.     /**

    296. 

  296.      * Compression Algorithms: Client to Server

    297. 

  297.      *

    298. 

  298.      * @see Net_SSH2::getCompressionAlgorithmsClient2Server()

    299. 

  299.      * @var Array

    300. 

  300.      * @access private

    301. 

  301.      */

    302. 

  302.     var $compression_algorithms_client_to_server;

    303. 

  303. 

    304. 

  304.     /**

    305. 

  305.      * Compression Algorithms: Server to Client

    306. 

  306.      *

    307. 

  307.      * @see Net_SSH2::getCompressionAlgorithmsServer2Client()

    308. 

  308.      * @var Array

    309. 

  309.      * @access private

    310. 

  310.      */

    311. 

  311.     var $compression_algorithms_server_to_client;

    312. 

  312. 

    313. 

  313.     /**

    314. 

  314.      * Languages: Server to Client

    315. 

  315.      *

    316. 

  316.      * @see Net_SSH2::getLanguagesServer2Client()

    317. 

  317.      * @var Array

    318. 

  318.      * @access private

    319. 

  319.      */

    320. 

  320.     var $languages_server_to_client;

    321. 

  321. 

    322. 

  322.     /**

    323. 

  323.      * Languages: Client to Server

    324. 

  324.      *

    325. 

  325.      * @see Net_SSH2::getLanguagesClient2Server()

    326. 

  326.      * @var Array

    327. 

  327.      * @access private

    328. 

  328.      */

    329. 

  329.     var $languages_client_to_server;

    330. 

  330. 

    331. 

  331.     /**

    332. 

  332.      * Block Size for Server to Client Encryption

    333. 

  333.      *

    334. 

  334.      * "Note that the length of the concatenation of 'packet_length',

    335. 

  335.      *  'padding_length', 'payload', and 'random padding' MUST be a multiple

    336. 

  336.      *  of the cipher block size or 8, whichever is larger.  This constraint

    337. 

  337.      *  MUST be enforced, even when using stream ciphers."

    338. 

  338.      *

    339. 

  339.      *  -- http://tools.ietf.org/html/rfc4253#section-6

    340. 

  340.      *

    341. 

  341.      * @see Net_SSH2::Net_SSH2()

    342. 

  342.      * @see Net_SSH2::_send_binary_packet()

    343. 

  343.      * @var Integer

    344. 

  344.      * @access private

    345. 

  345.      */

    346. 

  346.     var $encrypt_block_size = 8;

    347. 

  347. 

    348. 

  348.     /**

    349. 

  349.      * Block Size for Client to Server Encryption

    350. 

  350.      *

    351. 

  351.      * @see Net_SSH2::Net_SSH2()

    352. 

  352.      * @see Net_SSH2::_get_binary_packet()

    353. 

  353.      * @var Integer

    354. 

  354.      * @access private

    355. 

  355.      */

    356. 

  356.     var $decrypt_block_size = 8;

    357. 

  357. 

    358. 

  358.     /**

    359. 

  359.      * Server to Client Encryption Object

    360. 

  360.      *

    361. 

  361.      * @see Net_SSH2::_get_binary_packet()

    362. 

  362.      * @var Object

    363. 

  363.      * @access private

    364. 

  364.      */

    365. 

  365.     var $decrypt = false;

    366. 

  366. 

    367. 

  367.     /**

    368. 

  368.      * Client to Server Encryption Object

    369. 

  369.      *

    370. 

  370.      * @see Net_SSH2::_send_binary_packet()

    371. 

  371.      * @var Object

    372. 

  372.      * @access private

    373. 

  373.      */

    374. 

  374.     var $encrypt = false;

    375. 

  375. 

    376. 

  376.     /**

    377. 

  377.      * Client to Server HMAC Object

    378. 

  378.      *

    379. 

  379.      * @see Net_SSH2::_send_binary_packet()

    380. 

  380.      * @var Object

    381. 

  381.      * @access private

    382. 

  382.      */

    383. 

  383.     var $hmac_create = false;

    384. 

  384. 

    385. 

  385.     /**

    386. 

  386.      * Server to Client HMAC Object

    387. 

  387.      *

    388. 

  388.      * @see Net_SSH2::_get_binary_packet()

    389. 

  389.      * @var Object

    390. 

  390.      * @access private

    391. 

  391.      */

    392. 

  392.     var $hmac_check = false;

    393. 

  393. 

    394. 

  394.     /**

    395. 

  395.      * Size of server to client HMAC

    396. 

  396.      *

    397. 

  397.      * 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.

    398. 

  398.      * 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

    399. 

  399.      * append it.

    400. 

  400.      *

    401. 

  401.      * @see Net_SSH2::_get_binary_packet()

    402. 

  402.      * @var Integer

    403. 

  403.      * @access private

    404. 

  404.      */

    405. 

  405.     var $hmac_size = false;

    406. 

  406. 

    407. 

  407.     /**

    408. 

  408.      * Server Public Host Key

    409. 

  409.      *

    410. 

  410.      * @see Net_SSH2::getServerPublicHostKey()

    411. 

  411.      * @var String

    412. 

  412.      * @access private

    413. 

  413.      */

    414. 

  414.     var $server_public_host_key;

    415. 

  415. 

    416. 

  416.     /**

    417. 

  417.      * Session identifer

    418. 

  418.      *

    419. 

  419.      * "The exchange hash H from the first key exchange is additionally

    420. 

  420.      *  used as the session identifier, which is a unique identifier for

    421. 

  421.      *  this connection."

    422. 

  422.      *

    423. 

  423.      *  -- http://tools.ietf.org/html/rfc4253#section-7.2

    424. 

  424.      *

    425. 

  425.      * @see Net_SSH2::_key_exchange()

    426. 

  426.      * @var String

    427. 

  427.      * @access private

    428. 

  428.      */

    429. 

  429.     var $session_id = false;

    430. 

  430. 

    431. 

  431.     /**

    432. 

  432.      * Exchange hash

    433. 

  433.      *

    434. 

  434.      * The current exchange hash

    435. 

  435.      *

    436. 

  436.      * @see Net_SSH2::_key_exchange()

    437. 

  437.      * @var String

    438. 

  438.      * @access private

    439. 

  439.      */

    440. 

  440.     var $exchange_hash = false;

    441. 

  441. 

    442. 

  442.     /**

    443. 

  443.      * Message Numbers

    444. 

  444.      *

    445. 

  445.      * @see Net_SSH2::Net_SSH2()

    446. 

  446.      * @var Array

    447. 

  447.      * @access private

    448. 

  448.      */

    449. 

  449.     var $message_numbers = array();

    450. 

  450. 

    451. 

  451.     /**

    452. 

  452.      * Disconnection Message 'reason codes' defined in RFC4253

    453. 

  453.      *

    454. 

  454.      * @see Net_SSH2::Net_SSH2()

    455. 

  455.      * @var Array

    456. 

  456.      * @access private

    457. 

  457.      */

    458. 

  458.     var $disconnect_reasons = array();

    459. 

  459. 

    460. 

  460.     /**

    461. 

  461.      * SSH_MSG_CHANNEL_OPEN_FAILURE 'reason codes', defined in RFC4254

    462. 

  462.      *

    463. 

  463.      * @see Net_SSH2::Net_SSH2()

    464. 

  464.      * @var Array

    465. 

  465.      * @access private

    466. 

  466.      */

    467. 

  467.     var $channel_open_failure_reasons = array();

    468. 

  468. 

    469. 

  469.     /**

    470. 

  470.      * Terminal Modes

    471. 

  471.      *

    472. 

  472.      * @link http://tools.ietf.org/html/rfc4254#section-8

    473. 

  473.      * @see Net_SSH2::Net_SSH2()

    474. 

  474.      * @var Array

    475. 

  475.      * @access private

    476. 

  476.      */

    477. 

  477.     var $terminal_modes = array();

    478. 

  478. 

    479. 

  479.     /**

    480. 

  480.      * SSH_MSG_CHANNEL_EXTENDED_DATA's data_type_codes

    481. 

  481.      *

    482. 

  482.      * @link http://tools.ietf.org/html/rfc4254#section-5.2

    483. 

  483.      * @see Net_SSH2::Net_SSH2()

    484. 

  484.      * @var Array

    485. 

  485.      * @access private

    486. 

  486.      */

    487. 

  487.     var $channel_extended_data_type_codes = array();

    488. 

  488. 

    489. 

  489.     /**

    490. 

  490.      * Send Sequence Number

    491. 

  491.      *

    492. 

  492.      * See 'Section 6.4.  Data Integrity' of rfc4253 for more info.

    493. 

  493.      *

    494. 

  494.      * @see Net_SSH2::_send_binary_packet()

    495. 

  495.      * @var Integer

    496. 

  496.      * @access private

    497. 

  497.      */

    498. 

  498.     var $send_seq_no = 0;

    499. 

  499. 

    500. 

  500.     /**

    501. 

  501.      * Get Sequence Number

    502. 

  502.      *

    503. 

  503.      * See 'Section 6.4.  Data Integrity' of rfc4253 for more info.

    504. 

  504.      *

    505. 

  505.      * @see Net_SSH2::_get_binary_packet()

    506. 

  506.      * @var Integer

    507. 

  507.      * @access private

    508. 

  508.      */

    509. 

  509.     var $get_seq_no = 0;

    510. 

  510. 

    511. 

  511.     /**

    512. 

  512.      * Server Channels

    513. 

  513.      *

    514. 

  514.      * Maps client channels to server channels

    515. 

  515.      *

    516. 

  516.      * @see Net_SSH2::_get_channel_packet()

    517. 

  517.      * @see Net_SSH2::exec()

    518. 

  518.      * @var Array

    519. 

  519.      * @access private

    520. 

  520.      */

    521. 

  521.     var $server_channels = array();

    522. 

  522. 

    523. 

  523.     /**

    524. 

  524.      * Channel Buffers

    525. 

  525.      *

    526. 

  526.      * If a client requests a packet from one channel but receives two packets from another those packets should

    527. 

  527.      * be placed in a buffer

    528. 

  528.      *

    529. 

  529.      * @see Net_SSH2::_get_channel_packet()

    530. 

  530.      * @see Net_SSH2::exec()

    531. 

  531.      * @var Array

    532. 

  532.      * @access private

    533. 

  533.      */

    534. 

  534.     var $channel_buffers = array();

    535. 

  535. 

    536. 

  536.     /**

    537. 

  537.      * Channel Status

    538. 

  538.      *

    539. 

  539.      * Contains the type of the last sent message

    540. 

  540.      *

    541. 

  541.      * @see Net_SSH2::_get_channel_packet()

    542. 

  542.      * @var Array

    543. 

  543.      * @access private

    544. 

  544.      */

    545. 

  545.     var $channel_status = array();

    546. 

  546. 

    547. 

  547.     /**

    548. 

  548.      * Packet Size

    549. 

  549.      *

    550. 

  550.      * Maximum packet size indexed by channel

    551. 

  551.      *

    552. 

  552.      * @see Net_SSH2::_send_channel_packet()

    553. 

  553.      * @var Array

    554. 

  554.      * @access private

    555. 

  555.      */

    556. 

  556.     var $packet_size_client_to_server = array();

    557. 

  557. 

    558. 

  558.     /**

    559. 

  559.      * Message Number Log

    560. 

  560.      *

    561. 

  561.      * @see Net_SSH2::getLog()

    562. 

  562.      * @var Array

    563. 

  563.      * @access private

    564. 

  564.      */

    565. 

  565.     var $message_number_log = array();

    566. 

  566. 

    567. 

  567.     /**

    568. 

  568.      * Message Log

    569. 

  569.      *

    570. 

  570.      * @see Net_SSH2::getLog()

    571. 

  571.      * @var Array

    572. 

  572.      * @access private

    573. 

  573.      */

    574. 

  574.     var $message_log = array();

    575. 

  575. 

    576. 

  576.     /**

    577. 

  577.      * The Window Size

    578. 

  578.      *

    579. 

  579.      * Bytes the other party can send before it must wait for the window to be adjusted (0x7FFFFFFF = 4GB)

    580. 

  580.      *

    581. 

  581.      * @var Integer

    582. 

  582.      * @see Net_SSH2::_send_channel_packet()

    583. 

  583.      * @see Net_SSH2::exec()

    584. 

  584.      * @access private

    585. 

  585.      */

    586. 

  586.     var $window_size = 0x7FFFFFFF;

    587. 

  587. 

    588. 

  588.     /**

    589. 

  589.      * Window size

    590. 

  590.      *

    591. 

  591.      * Window size indexed by channel

    592. 

  592.      *

    593. 

  593.      * @see Net_SSH2::_send_channel_packet()

    594. 

  594.      * @var Array

    595. 

  595.      * @access private

    596. 

  596.      */

    597. 

  597.     var $window_size_client_to_server = array();

    598. 

  598. 

    599. 

  599.     /**

    600. 

  600.      * Server signature

    601. 

  601.      *

    602. 

  602.      * Verified against $this->session_id

    603. 

  603.      *

    604. 

  604.      * @see Net_SSH2::getServerPublicHostKey()

    605. 

  605.      * @var String

    606. 

  606.      * @access private

    607. 

  607.      */

    608. 

  608.     var $signature = '';

    609. 

  609. 

    610. 

  610.     /**

    611. 

  611.      * Server signature format

    612. 

  612.      *

    613. 

  613.      * ssh-rsa or ssh-dss.

    614. 

  614.      *

    615. 

  615.      * @see Net_SSH2::getServerPublicHostKey()

    616. 

  616.      * @var String

    617. 

  617.      * @access private

    618. 

  618.      */

    619. 

  619.     var $signature_format = '';

    620. 

  620. 

    621. 

  621.     /**

    622. 

  622.      * Interactive Buffer

    623. 

  623.      *

    624. 

  624.      * @see Net_SSH2::read()

    625. 

  625.      * @var Array

    626. 

  626.      * @access private

    627. 

  627.      */

    628. 

  628.     var $interactiveBuffer = '';

    629. 

  629. 

    630. 

  630.     /**

    631. 

  631.      * Current log size

    632. 

  632.      *

    633. 

  633.      * Should never exceed NET_SSH2_LOG_MAX_SIZE

    634. 

  634.      *

    635. 

  635.      * @see Net_SSH2::_send_binary_packet()

    636. 

  636.      * @see Net_SSH2::_get_binary_packet()

    637. 

  637.      * @var Integer

    638. 

  638.      * @access private

    639. 

  639.      */

    640. 

  640.     var $log_size;

    641. 

  641. 

    642. 

  642.     /**

    643. 

  643.      * Timeout

    644. 

  644.      *

    645. 

  645.      * @see Net_SSH2::setTimeout()

    646. 

  646.      * @access private

    647. 

  647.      */

    648. 

  648.     var $timeout;

    649. 

  649. 

    650. 

  650.     /**

    651. 

  651.      * Current Timeout

    652. 

  652.      *

    653. 

  653.      * @see Net_SSH2::_get_channel_packet()

    654. 

  654.      * @access private

    655. 

  655.      */

    656. 

  656.     var $curTimeout;

    657. 

  657. 

    658. 

  658.     /**

    659. 

  659.      * Real-time log file pointer

    660. 

  660.      *

    661. 

  661.      * @see Net_SSH2::_append_log()

    662. 

  662.      * @access private

    663. 

  663.      */

    664. 

  664.     var $realtime_log_file;

    665. 

  665. 

    666. 

  666.     /**

    667. 

  667.      * Real-time log file size

    668. 

  668.      *

    669. 

  669.      * @see Net_SSH2::_append_log()

    670. 

  670.      * @access private

    671. 

  671.      */

    672. 

  672.     var $realtime_log_size;

    673. 

  673. 

    674. 

  674.     /**

    675. 

  675.      * Has the signature been validated?

    676. 

  676.      *

    677. 

  677.      * @see Net_SSH2::getServerPublicHostKey()

    678. 

  678.      * @access private

    679. 

  679.      */

    680. 

  680.     var $signature_validated = false;

    681. 

  681. 

    682. 

  682.     /**

    683. 

  683.      * Real-time log file wrap boolean

    684. 

  684.      *

    685. 

  685.      * @see Net_SSH2::_append_log()

    686. 

  686.      * @access private

    687. 

  687.      */

    688. 

  688.     var $realtime_log_wrap;

    689. 

  689. 

    690. 

  690.     /**

    691. 

  691.      * Default Constructor.

    692. 

  692.      *

    693. 

  693.      * Connects to an SSHv2 server

    694. 

  694.      *

    695. 

  695.      * @param String $host

    696. 

  696.      * @param optional Integer $port

    697. 

  697.      * @param optional Integer $timeout

    698. 

  698.      * @return Net_SSH2

    699. 

  699.      * @access public

    700. 

  700.      */

    701. 

  701.     function Net_SSH2($host, $port = 22, $timeout = 10)

    702. 

  702.     {

    703. 

  703.         $this->message_numbers = array(

    704. 

  704.             1 => 'NET_SSH2_MSG_DISCONNECT',

    705. 

  705.             2 => 'NET_SSH2_MSG_IGNORE',

    706. 

  706.             3 => 'NET_SSH2_MSG_UNIMPLEMENTED',

    707. 

  707.             4 => 'NET_SSH2_MSG_DEBUG',

    708. 

  708.             5 => 'NET_SSH2_MSG_SERVICE_REQUEST',

    709. 

  709.             6 => 'NET_SSH2_MSG_SERVICE_ACCEPT',

    710. 

  710.             20 => 'NET_SSH2_MSG_KEXINIT',

    711. 

  711.             21 => 'NET_SSH2_MSG_NEWKEYS',

    712. 

  712.             30 => 'NET_SSH2_MSG_KEXDH_INIT',

    713. 

  713.             31 => 'NET_SSH2_MSG_KEXDH_REPLY',

    714. 

  714.             50 => 'NET_SSH2_MSG_USERAUTH_REQUEST',

    715. 

  715.             51 => 'NET_SSH2_MSG_USERAUTH_FAILURE',

    716. 

  716.             52 => 'NET_SSH2_MSG_USERAUTH_SUCCESS',

    717. 

  717.             53 => 'NET_SSH2_MSG_USERAUTH_BANNER',

    718. 

  718. 

    719. 

  719.             80 => 'NET_SSH2_MSG_GLOBAL_REQUEST',

    720. 

  720.             81 => 'NET_SSH2_MSG_REQUEST_SUCCESS',

    721. 

  721.             82 => 'NET_SSH2_MSG_REQUEST_FAILURE',

    722. 

  722.             90 => 'NET_SSH2_MSG_CHANNEL_OPEN',

    723. 

  723.             91 => 'NET_SSH2_MSG_CHANNEL_OPEN_CONFIRMATION',

    724. 

  724.             92 => 'NET_SSH2_MSG_CHANNEL_OPEN_FAILURE',

    725. 

  725.             93 => 'NET_SSH2_MSG_CHANNEL_WINDOW_ADJUST',

    726. 

  726.             94 => 'NET_SSH2_MSG_CHANNEL_DATA',

    727. 

  727.             95 => 'NET_SSH2_MSG_CHANNEL_EXTENDED_DATA',

    728. 

  728.             96 => 'NET_SSH2_MSG_CHANNEL_EOF',

    729. 

  729.             97 => 'NET_SSH2_MSG_CHANNEL_CLOSE',

    730. 

  730.             98 => 'NET_SSH2_MSG_CHANNEL_REQUEST',

    731. 

  731.             99 => 'NET_SSH2_MSG_CHANNEL_SUCCESS',

    732. 

  732.             100 => 'NET_SSH2_MSG_CHANNEL_FAILURE'

    733. 

  733.         );

    734. 

  734.         $this->disconnect_reasons = array(

    735. 

  735.             1 => 'NET_SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT',

    736. 

  736.             2 => 'NET_SSH2_DISCONNECT_PROTOCOL_ERROR',

    737. 

  737.             3 => 'NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED',

    738. 

  738.             4 => 'NET_SSH2_DISCONNECT_RESERVED',

    739. 

  739.             5 => 'NET_SSH2_DISCONNECT_MAC_ERROR',

    740. 

  740.             6 => 'NET_SSH2_DISCONNECT_COMPRESSION_ERROR',

    741. 

  741.             7 => 'NET_SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE',

    742. 

  742.             8 => 'NET_SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED',

    743. 

  743.             9 => 'NET_SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE',

    744. 

  744.             10 => 'NET_SSH2_DISCONNECT_CONNECTION_LOST',

    745. 

  745.             11 => 'NET_SSH2_DISCONNECT_BY_APPLICATION',

    746. 

  746.             12 => 'NET_SSH2_DISCONNECT_TOO_MANY_CONNECTIONS',

    747. 

  747.             13 => 'NET_SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER',

    748. 

  748.             14 => 'NET_SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE',

    749. 

  749.             15 => 'NET_SSH2_DISCONNECT_ILLEGAL_USER_NAME'

    750. 

  750.         );

    751. 

  751.         $this->channel_open_failure_reasons = array(

    752. 

  752.             1 => 'NET_SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED'

    753. 

  753.         );

    754. 

  754.         $this->terminal_modes = array(

    755. 

  755.             0 => 'NET_SSH2_TTY_OP_END'

    756. 

  756.         );

    757. 

  757.         $this->channel_extended_data_type_codes = array(

    758. 

  758.             1 => 'NET_SSH2_EXTENDED_DATA_STDERR'

    759. 

  759.         );

    760. 

  760. 

    761. 

  761.         $this->_define_array(

    762. 

  762.             $this->message_numbers,

    763. 

  763.             $this->disconnect_reasons,

    764. 

  764.             $this->channel_open_failure_reasons,

    765. 

  765.             $this->terminal_modes,

    766. 

  766.             $this->channel_extended_data_type_codes,

    767. 

  767.             array(60 => 'NET_SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ'),

    768. 

  768.             array(60 => 'NET_SSH2_MSG_USERAUTH_PK_OK'),

    769. 

  769.             array(60 => 'NET_SSH2_MSG_USERAUTH_INFO_REQUEST',

    770. 

  770.                   61 => 'NET_SSH2_MSG_USERAUTH_INFO_RESPONSE')

    771. 

  771.         );

    772. 

  772. 

    773. 

  773.         $start = strtok(microtime(), ' ') + strtok(''); // http://php.net/microtime#61838

    774. 

  774.         $this->fsock = @fsockopen($host, $port, $errno, $errstr, $timeout);

    775. 

  775.         if (!$this->fsock) {

    776. 

  776.             user_error(rtrim("Cannot connect to $host. Error $errno. $errstr"), E_USER_NOTICE);

    777. 

  777.             return;

    778. 

  778.         }

    779. 

  779.         $elapsed = strtok(microtime(), ' ') + strtok('') - $start;

    780. 

  780. 

    781. 

  781.         if ($timeout - $elapsed <= 0) {

    782. 

  782.             user_error(rtrim("Cannot connect to $host. Timeout error"), E_USER_NOTICE);

    783. 

  783.             return;

    784. 

  784.         }

    785. 

  785. 

    786. 

  786.         $read = array($this->fsock);

    787. 

  787.         $write = $except = NULL;

    788. 

  788. 

    789. 

  789.         stream_set_blocking($this->fsock, false);

    790. 

  790. 

    791. 

  791.         // on windows this returns a "Warning: Invalid CRT parameters detected" error

    792. 

  792.         if (!@stream_select($read, $write, $except, $timeout - $elapsed)) {

    793. 

  793.             user_error(rtrim("Cannot connect to $host. Banner timeout"), E_USER_NOTICE);

    794. 

  794.             return;

    795. 

  795.         }

    796. 

  796. 

    797. 

  797.         stream_set_blocking($this->fsock, true);

    798. 

  798. 

    799. 

  799.         /* According to the SSH2 specs,

    800. 

  800. 

    801. 

  801.           "The server MAY send other lines of data before sending the version

    802. 

  802.            string.  Each line SHOULD be terminated by a Carriage Return and Line

    803. 

  803.            Feed.  Such lines MUST NOT begin with "SSH-", and SHOULD be encoded

    804. 

  804.            in ISO-10646 UTF-8 [RFC3629] (language is not specified).  Clients

    805. 

  805.            MUST be able to process such lines." */

    806. 

  806.         $temp = '';

    807. 

  807.         $extra = '';

    808. 

  808.         while (!feof($this->fsock) && !preg_match('#^SSH-(\d\.\d+)#', $temp, $matches)) {

    809. 

  809.             if (substr($temp, -2) == "\r\n") {

    810. 

  810.                 $extra.= $temp;

    811. 

  811.                 $temp = '';

    812. 

  812.             }

    813. 

  813.             $temp.= fgets($this->fsock, 255);

    814. 

  814.         }

    815. 

  815. 

    816. 

  816.         if (feof($this->fsock)) {

    817. 

  817.             user_error('Connection closed by server', E_USER_NOTICE);

    818. 

  818.             return false;

    819. 

  819.         }

    820. 

  820. 

    821. 

  821.         $ext = array();

    822. 

  822.         if (extension_loaded('mcrypt')) {

    823. 

  823.             $ext[] = 'mcrypt';

    824. 

  824.         }

    825. 

  825.         if (extension_loaded('gmp')) {

    826. 

  826.             $ext[] = 'gmp';

    827. 

  827.         } else if (extension_loaded('bcmath')) {

    828. 

  828.             $ext[] = 'bcmath';

    829. 

  829.         }

    830. 

  830. 

    831. 

  831.         if (!empty($ext)) {

    832. 

  832.             $this->identifier.= ' (' . implode(', ', $ext) . ')';

    833. 

  833.         }

    834. 

  834. 

    835. 

  835.         if (defined('NET_SSH2_LOGGING')) {

    836. 

  836.             $this->message_number_log[] = '<-';

    837. 

  837.             $this->message_number_log[] = '->';

    838. 

  838. 

    839. 

  839.             if (NET_SSH2_LOGGING == NET_SSH2_LOG_COMPLEX) {

    840. 

  840.                 $this->message_log[] = $temp;

    841. 

  841.                 $this->message_log[] = $this->identifier . "\r\n";

    842. 

  842.             }

    843. 

  843.         }

    844. 

  844. 

    845. 

  845.         $this->server_identifier = trim($temp, "\r\n");

    846. 

  846.         if (!empty($extra)) {

    847. 

  847.             $this->errors[] = utf8_decode($extra);

    848. 

  848.         }

    849. 

  849. 

    850. 

  850.         if ($matches[1] != '1.99' && $matches[1] != '2.0') {

    851. 

  851.             user_error("Cannot connect to SSH $matches[1] servers", E_USER_NOTICE);

    852. 

  852.             return;

    853. 

  853.         }

    854. 

  854. 

    855. 

  855.         fputs($this->fsock, $this->identifier . "\r\n");

    856. 

  856. 

    857. 

  857.         $response = $this->_get_binary_packet();

    858. 

  858.         if ($response === false) {

    859. 

  859.             user_error('Connection closed by server', E_USER_NOTICE);

    860. 

  860.             return;

    861. 

  861.         }

    862. 

  862. 

    863. 

  863.         if (ord($response[0]) != NET_SSH2_MSG_KEXINIT) {

    864. 

  864.             user_error('Expected SSH_MSG_KEXINIT', E_USER_NOTICE);

    865. 

  865.             return;

    866. 

  866.         }

    867. 

  867. 

    868. 

  868.         if (!$this->_key_exchange($response)) {

    869. 

  869.             return;

    870. 

  870.         }

    871. 

  871. 

    872. 

  872.         $this->bitmap = NET_SSH2_MASK_CONSTRUCTOR;

    873. 

  873.     }

    874. 

  874. 

    875. 

  875.     /**

    876. 

  876.      * Key Exchange

    877. 

  877.      *

    878. 

  878.      * @param String $kexinit_payload_server

    879. 

  879.      * @access private

    880. 

  880.      */

    881. 

  881.     function _key_exchange($kexinit_payload_server)

    882. 

  882.     {

    883. 

  883.         static $kex_algorithms = array(

    884. 

  884.             'diffie-hellman-group1-sha1', // REQUIRED

    885. 

  885.             'diffie-hellman-group14-sha1' // REQUIRED

    886. 

  886.         );

    887. 

  887. 

    888. 

  888.         static $server_host_key_algorithms = array(

    889. 

  889.             'ssh-rsa', // RECOMMENDED  sign   Raw RSA Key

    890. 

  890.             'ssh-dss'  // REQUIRED     sign   Raw DSS Key

    891. 

  891.         );

    892. 

  892. 

    893. 

  893.         static $encryption_algorithms = array(

    894. 

  894.             // from <http://tools.ietf.org/html/rfc4345#section-4>:

    895. 

  895.             'arcfour256',

    896. 

  896.             'arcfour128',

    897. 

  897. 

    898. 

  898.             'arcfour',    // OPTIONAL          the ARCFOUR stream cipher with a 128-bit key

    899. 

  899. 

    900. 

  900.             'aes128-cbc', // RECOMMENDED       AES with a 128-bit key

    901. 

  901.             'aes192-cbc', // OPTIONAL          AES with a 192-bit key

    902. 

  902.             'aes256-cbc', // OPTIONAL          AES in CBC mode, with a 256-bit key

    903. 

  903. 

    904. 

  904.             // from <http://tools.ietf.org/html/rfc4344#section-4>:

    905. 

  905.             'aes128-ctr', // RECOMMENDED       AES (Rijndael) in SDCTR mode, with 128-bit key

    906. 

  906.             'aes192-ctr', // RECOMMENDED       AES with 192-bit key

    907. 

  907.             'aes256-ctr', // RECOMMENDED       AES with 256-bit key

    908. 

  908.             '3des-ctr',   // RECOMMENDED       Three-key 3DES in SDCTR mode

    909. 

  909. 

    910. 

  910.             '3des-cbc',   // REQUIRED          three-key 3DES in CBC mode

    911. 

  911.             'none'        // OPTIONAL          no encryption; NOT RECOMMENDED

    912. 

  912.         );

    913. 

  913. 

    914. 

  914.         static $mac_algorithms = array(

    915. 

  915.             'hmac-sha1-96', // RECOMMENDED     first 96 bits of HMAC-SHA1 (digest length = 12, key length = 20)

    916. 

  916.             'hmac-sha1',    // REQUIRED        HMAC-SHA1 (digest length = key length = 20)

    917. 

  917.             'hmac-md5-96',  // OPTIONAL        first 96 bits of HMAC-MD5 (digest length = 12, key length = 16)

    918. 

  918.             'hmac-md5',     // OPTIONAL        HMAC-MD5 (digest length = key length = 16)

    919. 

  919.             'none'          // OPTIONAL        no MAC; NOT RECOMMENDED

    920. 

  920.         );

    921. 

  921. 

    922. 

  922.         static $compression_algorithms = array(

    923. 

  923.             'none'   // REQUIRED        no compression

    924. 

  924.             //'zlib' // OPTIONAL        ZLIB (LZ77) compression

    925. 

  925.         );

    926. 

  926. 

    927. 

  927.         static $str_kex_algorithms, $str_server_host_key_algorithms,

    928. 

  928.                $encryption_algorithms_server_to_client, $mac_algorithms_server_to_client, $compression_algorithms_server_to_client,

    929. 

  929.                $encryption_algorithms_client_to_server, $mac_algorithms_client_to_server, $compression_algorithms_client_to_server;

    930. 

  930. 

    931. 

  931.         if (empty($str_kex_algorithms)) {

    932. 

  932.             $str_kex_algorithms = implode(',', $kex_algorithms);

    933. 

  933.             $str_server_host_key_algorithms = implode(',', $server_host_key_algorithms);

    934. 

  934.             $encryption_algorithms_server_to_client = $encryption_algorithms_client_to_server = implode(',', $encryption_algorithms);

    935. 

  935.             $mac_algorithms_server_to_client = $mac_algorithms_client_to_server = implode(',', $mac_algorithms);

    936. 

  936.             $compression_algorithms_server_to_client = $compression_algorithms_client_to_server = implode(',', $compression_algorithms);

    937. 

  937.         }

    938. 

  938. 

    939. 

  939.         $client_cookie = '';

    940. 

  940.         for ($i = 0; $i < 16; $i++) {

    941. 

  941.             $client_cookie.= chr(crypt_random(0, 255));

    942. 

  942.         }

    943. 

  943. 

    944. 

  944.         $response = $kexinit_payload_server;

    945. 

  945.         $this->_string_shift($response, 1); // skip past the message number (it should be SSH_MSG_KEXINIT)

    946. 

  946.         $server_cookie = $this->_string_shift($response, 16);

    947. 

  947. 

    948. 

  948.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    949. 

  949.         $this->kex_algorithms = explode(',', $this->_string_shift($response, $temp['length']));

    950. 

  950. 

    951. 

  951.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    952. 

  952.         $this->server_host_key_algorithms = explode(',', $this->_string_shift($response, $temp['length']));

    953. 

  953. 

    954. 

  954.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    955. 

  955.         $this->encryption_algorithms_client_to_server = explode(',', $this->_string_shift($response, $temp['length']));

    956. 

  956. 

    957. 

  957.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    958. 

  958.         $this->encryption_algorithms_server_to_client = explode(',', $this->_string_shift($response, $temp['length']));

    959. 

  959. 

    960. 

  960.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    961. 

  961.         $this->mac_algorithms_client_to_server = explode(',', $this->_string_shift($response, $temp['length']));

    962. 

  962. 

    963. 

  963.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    964. 

  964.         $this->mac_algorithms_server_to_client = explode(',', $this->_string_shift($response, $temp['length']));

    965. 

  965. 

    966. 

  966.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    967. 

  967.         $this->compression_algorithms_client_to_server = explode(',', $this->_string_shift($response, $temp['length']));

    968. 

  968. 

    969. 

  969.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    970. 

  970.         $this->compression_algorithms_server_to_client = explode(',', $this->_string_shift($response, $temp['length']));

    971. 

  971. 

    972. 

  972.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    973. 

  973.         $this->languages_client_to_server = explode(',', $this->_string_shift($response, $temp['length']));

    974. 

  974. 

    975. 

  975.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    976. 

  976.         $this->languages_server_to_client = explode(',', $this->_string_shift($response, $temp['length']));

    977. 

  977. 

    978. 

  978.         extract(unpack('Cfirst_kex_packet_follows', $this->_string_shift($response, 1)));

    979. 

  979.         $first_kex_packet_follows = $first_kex_packet_follows != 0;

    980. 

  980. 

    981. 

  981.         // the sending of SSH2_MSG_KEXINIT could go in one of two places.  this is the second place.

    982. 

  982.         $kexinit_payload_client = pack('Ca*Na*Na*Na*Na*Na*Na*Na*Na*Na*Na*CN',

    983. 

  983.             NET_SSH2_MSG_KEXINIT, $client_cookie, strlen($str_kex_algorithms), $str_kex_algorithms,

    984. 

  984.             strlen($str_server_host_key_algorithms), $str_server_host_key_algorithms, strlen($encryption_algorithms_client_to_server),

    985. 

  985.             $encryption_algorithms_client_to_server, strlen($encryption_algorithms_server_to_client), $encryption_algorithms_server_to_client,

    986. 

  986.             strlen($mac_algorithms_client_to_server), $mac_algorithms_client_to_server, strlen($mac_algorithms_server_to_client),

    987. 

  987.             $mac_algorithms_server_to_client, strlen($compression_algorithms_client_to_server), $compression_algorithms_client_to_server,

    988. 

  988.             strlen($compression_algorithms_server_to_client), $compression_algorithms_server_to_client, 0, '', 0, '',

    989. 

  989.             0, 0

    990. 

  990.         );

    991. 

  991. 

    992. 

  992.         if (!$this->_send_binary_packet($kexinit_payload_client)) {

    993. 

  993.             return false;

    994. 

  994.         }

    995. 

  995.         // here ends the second place.

    996. 

  996. 

    997. 

  997.         // we need to decide upon the symmetric encryption algorithms before we do the diffie-hellman key exchange

    998. 

  998.         for ($i = 0; $i < count($encryption_algorithms) && !in_array($encryption_algorithms[$i], $this->encryption_algorithms_server_to_client); $i++);

    999. 

  999.         if ($i == count($encryption_algorithms)) {

    1000. 

  1000.             user_error('No compatible server to client encryption algorithms found', E_USER_NOTICE);

    1001. 

  1001.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1002. 

  1002.         }

    1003. 

  1003. 

    1004. 

  1004.         // we don't initialize any crypto-objects, yet - we do that, later. for now, we need the lengths to make the

    1005. 

  1005.         // diffie-hellman key exchange as fast as possible

    1006. 

  1006.         $decrypt = $encryption_algorithms[$i];

    1007. 

  1007.         switch ($decrypt) {

    1008. 

  1008.             case '3des-cbc':

    1009. 

  1009.             case '3des-ctr':

    1010. 

  1010.                 $decryptKeyLength = 24; // eg. 192 / 8

    1011. 

  1011.                 break;

    1012. 

  1012.             case 'aes256-cbc':

    1013. 

  1013.             case 'aes256-ctr':

    1014. 

  1014.                 $decryptKeyLength = 32; // eg. 256 / 8

    1015. 

  1015.                 break;

    1016. 

  1016.             case 'aes192-cbc':

    1017. 

  1017.             case 'aes192-ctr':

    1018. 

  1018.                 $decryptKeyLength = 24; // eg. 192 / 8

    1019. 

  1019.                 break;

    1020. 

  1020.             case 'aes128-cbc':

    1021. 

  1021.             case 'aes128-ctr':

    1022. 

  1022.                 $decryptKeyLength = 16; // eg. 128 / 8

    1023. 

  1023.                 break;

    1024. 

  1024.             case 'arcfour':

    1025. 

  1025.             case 'arcfour128':

    1026. 

  1026.                 $decryptKeyLength = 16; // eg. 128 / 8

    1027. 

  1027.                 break;

    1028. 

  1028.             case 'arcfour256':

    1029. 

  1029.                 $decryptKeyLength = 32; // eg. 128 / 8

    1030. 

  1030.                 break;

    1031. 

  1031.             case 'none';

    1032. 

  1032.                 $decryptKeyLength = 0;

    1033. 

  1033.         }

    1034. 

  1034. 

    1035. 

  1035.         for ($i = 0; $i < count($encryption_algorithms) && !in_array($encryption_algorithms[$i], $this->encryption_algorithms_client_to_server); $i++);

    1036. 

  1036.         if ($i == count($encryption_algorithms)) {

    1037. 

  1037.             user_error('No compatible client to server encryption algorithms found', E_USER_NOTICE);

    1038. 

  1038.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1039. 

  1039.         }

    1040. 

  1040. 

    1041. 

  1041.         $encrypt = $encryption_algorithms[$i];

    1042. 

  1042.         switch ($encrypt) {

    1043. 

  1043.             case '3des-cbc':

    1044. 

  1044.             case '3des-ctr':

    1045. 

  1045.                 $encryptKeyLength = 24;

    1046. 

  1046.                 break;

    1047. 

  1047.             case 'aes256-cbc':

    1048. 

  1048.             case 'aes256-ctr':

    1049. 

  1049.                 $encryptKeyLength = 32;

    1050. 

  1050.                 break;

    1051. 

  1051.             case 'aes192-cbc':

    1052. 

  1052.             case 'aes192-ctr':

    1053. 

  1053.                 $encryptKeyLength = 24;

    1054. 

  1054.                 break;

    1055. 

  1055.             case 'aes128-cbc':

    1056. 

  1056.             case 'aes128-ctr':

    1057. 

  1057.                 $encryptKeyLength = 16;

    1058. 

  1058.                 break;

    1059. 

  1059.             case 'arcfour':

    1060. 

  1060.             case 'arcfour128':

    1061. 

  1061.                 $encryptKeyLength = 16;

    1062. 

  1062.                 break;

    1063. 

  1063.             case 'arcfour256':

    1064. 

  1064.                 $encryptKeyLength = 32;

    1065. 

  1065.                 break;

    1066. 

  1066.             case 'none';

    1067. 

  1067.                 $encryptKeyLength = 0;

    1068. 

  1068.         }

    1069. 

  1069. 

    1070. 

  1070.         $keyLength = $decryptKeyLength > $encryptKeyLength ? $decryptKeyLength : $encryptKeyLength;

    1071. 

  1071. 

    1072. 

  1072.         // through diffie-hellman key exchange a symmetric key is obtained

    1073. 

  1073.         for ($i = 0; $i < count($kex_algorithms) && !in_array($kex_algorithms[$i], $this->kex_algorithms); $i++);

    1074. 

  1074.         if ($i == count($kex_algorithms)) {

    1075. 

  1075.             user_error('No compatible key exchange algorithms found', E_USER_NOTICE);

    1076. 

  1076.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1077. 

  1077.         }

    1078. 

  1078. 

    1079. 

  1079.         switch ($kex_algorithms[$i]) {

    1080. 

  1080.             // see http://tools.ietf.org/html/rfc2409#section-6.2 and 

    1081. 

  1081.             // http://tools.ietf.org/html/rfc2412, appendex E

    1082. 

  1082.             case 'diffie-hellman-group1-sha1':

    1083. 

  1083.                 $p = pack('H256', 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' . 

    1084. 

  1084.                                   '020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437' . 

    1085. 

  1085.                                   '4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' . 

    1086. 

  1086.                                   'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF');

    1087. 

  1087.                 $keyLength = $keyLength < 160 ? $keyLength : 160;

    1088. 

  1088.                 $hash = 'sha1';

    1089. 

  1089.                 break;

    1090. 

  1090.             // see http://tools.ietf.org/html/rfc3526#section-3

    1091. 

  1091.             case 'diffie-hellman-group14-sha1':

    1092. 

  1092.                 $p = pack('H512', 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' . 

    1093. 

  1093.                                   '020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437' . 

    1094. 

  1094.                                   '4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' . 

    1095. 

  1095.                                   'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF05' . 

    1096. 

  1096.                                   '98DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB' . 

    1097. 

  1097.                                   '9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B' . 

    1098. 

  1098.                                   'E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718' . 

    1099. 

  1099.                                   '3995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF');

    1100. 

  1100.                 $keyLength = $keyLength < 160 ? $keyLength : 160;

    1101. 

  1101.                 $hash = 'sha1';

    1102. 

  1102.         }

    1103. 

  1103. 

    1104. 

  1104.         $p = new Math_BigInteger($p, 256);

    1105. 

  1105.         //$q = $p->bitwise_rightShift(1);

    1106. 

  1106. 

    1107. 

  1107.         /* To increase the speed of the key exchange, both client and server may

    1108. 

  1108.            reduce the size of their private exponents.  It should be at least

    1109. 

  1109.            twice as long as the key material that is generated from the shared

    1110. 

  1110.            secret.  For more details, see the paper by van Oorschot and Wiener

    1111. 

  1111.            [VAN-OORSCHOT].

    1112. 

  1112. 

    1113. 

  1113.            -- http://tools.ietf.org/html/rfc4419#section-6.2 */

    1114. 

  1114.         $q = new Math_BigInteger(1);

    1115. 

  1115.         $q = $q->bitwise_leftShift(2 * $keyLength);

    1116. 

  1116.         $q = $q->subtract(new Math_BigInteger(1));

    1117. 

  1117. 

    1118. 

  1118.         $g = new Math_BigInteger(2);

    1119. 

  1119.         $x = new Math_BigInteger();

    1120. 

  1120.         $x->setRandomGenerator('crypt_random');

    1121. 

  1121.         $x = $x->random(new Math_BigInteger(1), $q);

    1122. 

  1122.         $e = $g->modPow($x, $p);

    1123. 

  1123. 

    1124. 

  1124.         $eBytes = $e->toBytes(true);

    1125. 

  1125.         $data = pack('CNa*', NET_SSH2_MSG_KEXDH_INIT, strlen($eBytes), $eBytes);

    1126. 

  1126. 

    1127. 

  1127.         if (!$this->_send_binary_packet($data)) {

    1128. 

  1128.             user_error('Connection closed by server', E_USER_NOTICE);

    1129. 

  1129.             return false;

    1130. 

  1130.         }

    1131. 

  1131. 

    1132. 

  1132.         $response = $this->_get_binary_packet();

    1133. 

  1133.         if ($response === false) {

    1134. 

  1134.             user_error('Connection closed by server', E_USER_NOTICE);

    1135. 

  1135.             return false;

    1136. 

  1136.         }

    1137. 

  1137.         extract(unpack('Ctype', $this->_string_shift($response, 1)));

    1138. 

  1138. 

    1139. 

  1139.         if ($type != NET_SSH2_MSG_KEXDH_REPLY) {

    1140. 

  1140.             user_error('Expected SSH_MSG_KEXDH_REPLY', E_USER_NOTICE);

    1141. 

  1141.             return false;

    1142. 

  1142.         }

    1143. 

  1143. 

    1144. 

  1144.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    1145. 

  1145.         $this->server_public_host_key = $server_public_host_key = $this->_string_shift($response, $temp['length']);

    1146. 

  1146. 

    1147. 

  1147.         $temp = unpack('Nlength', $this->_string_shift($server_public_host_key, 4));

    1148. 

  1148.         $public_key_format = $this->_string_shift($server_public_host_key, $temp['length']);

    1149. 

  1149. 

    1150. 

  1150.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    1151. 

  1151.         $fBytes = $this->_string_shift($response, $temp['length']);

    1152. 

  1152.         $f = new Math_BigInteger($fBytes, -256);

    1153. 

  1153. 

    1154. 

  1154.         $temp = unpack('Nlength', $this->_string_shift($response, 4));

    1155. 

  1155.         $this->signature = $this->_string_shift($response, $temp['length']);

    1156. 

  1156. 

    1157. 

  1157.         $temp = unpack('Nlength', $this->_string_shift($this->signature, 4));

    1158. 

  1158.         $this->signature_format = $this->_string_shift($this->signature, $temp['length']);

    1159. 

  1159. 

    1160. 

  1160.         $key = $f->modPow($x, $p);

    1161. 

  1161.         $keyBytes = $key->toBytes(true);

    1162. 

  1162. 

    1163. 

  1163.         $this->exchange_hash = pack('Na*Na*Na*Na*Na*Na*Na*Na*',

    1164. 

  1164.             strlen($this->identifier), $this->identifier, strlen($this->server_identifier), $this->server_identifier,

    1165. 

  1165.             strlen($kexinit_payload_client), $kexinit_payload_client, strlen($kexinit_payload_server),

    1166. 

  1166.             $kexinit_payload_server, strlen($this->server_public_host_key), $this->server_public_host_key, strlen($eBytes),

    1167. 

  1167.             $eBytes, strlen($fBytes), $fBytes, strlen($keyBytes), $keyBytes

    1168. 

  1168.         );

    1169. 

  1169. 

    1170. 

  1170.         $this->exchange_hash = pack('H*', $hash($this->exchange_hash));

    1171. 

  1171. 

    1172. 

  1172.         if ($this->session_id === false) {

    1173. 

  1173.             $this->session_id = $this->exchange_hash;

    1174. 

  1174.         }

    1175. 

  1175. 

    1176. 

  1176.         for ($i = 0; $i < count($server_host_key_algorithms) && !in_array($server_host_key_algorithms[$i], $this->server_host_key_algorithms); $i++);

    1177. 

  1177.         if ($i == count($server_host_key_algorithms)) {

    1178. 

  1178.             user_error('No compatible server host key algorithms found', E_USER_NOTICE);

    1179. 

  1179.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1180. 

  1180.         }

    1181. 

  1181. 

    1182. 

  1182.         if ($public_key_format != $server_host_key_algorithms[$i] || $this->signature_format != $server_host_key_algorithms[$i]) {

    1183. 

  1183.             user_error('Sever Host Key Algorithm Mismatch', E_USER_NOTICE);

    1184. 

  1184.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1185. 

  1185.         }

    1186. 

  1186. 

    1187. 

  1187.         $packet = pack('C',

    1188. 

  1188.             NET_SSH2_MSG_NEWKEYS

    1189. 

  1189.         );

    1190. 

  1190. 

    1191. 

  1191.         if (!$this->_send_binary_packet($packet)) {

    1192. 

  1192.             return false;

    1193. 

  1193.         }

    1194. 

  1194. 

    1195. 

  1195.         $response = $this->_get_binary_packet();

    1196. 

  1196. 

    1197. 

  1197.         if ($response === false) {

    1198. 

  1198.             user_error('Connection closed by server', E_USER_NOTICE);

    1199. 

  1199.             return false;

    1200. 

  1200.         }

    1201. 

  1201. 

    1202. 

  1202.         extract(unpack('Ctype', $this->_string_shift($response, 1)));

    1203. 

  1203. 

    1204. 

  1204.         if ($type != NET_SSH2_MSG_NEWKEYS) {

    1205. 

  1205.             user_error('Expected SSH_MSG_NEWKEYS', E_USER_NOTICE);

    1206. 

  1206.             return false;

    1207. 

  1207.         }

    1208. 

  1208. 

    1209. 

  1209.         switch ($encrypt) {

    1210. 

  1210.             case '3des-cbc':

    1211. 

  1211.                 $this->encrypt = new Crypt_TripleDES();

    1212. 

  1212.                 // $this->encrypt_block_size = 64 / 8 == the default

    1213. 

  1213.                 break;

    1214. 

  1214.             case '3des-ctr':

    1215. 

  1215.                 $this->encrypt = new Crypt_TripleDES(CRYPT_DES_MODE_CTR);

    1216. 

  1216.                 // $this->encrypt_block_size = 64 / 8 == the default

    1217. 

  1217.                 break;

    1218. 

  1218.             case 'aes256-cbc':

    1219. 

  1219.             case 'aes192-cbc':

    1220. 

  1220.             case 'aes128-cbc':

    1221. 

  1221.                 $this->encrypt = new Crypt_AES();

    1222. 

  1222.                 $this->encrypt_block_size = 16; // eg. 128 / 8

    1223. 

  1223.                 break;

    1224. 

  1224.             case 'aes256-ctr':

    1225. 

  1225.             case 'aes192-ctr':

    1226. 

  1226.             case 'aes128-ctr':

    1227. 

  1227.                 $this->encrypt = new Crypt_AES(CRYPT_AES_MODE_CTR);

    1228. 

  1228.                 $this->encrypt_block_size = 16; // eg. 128 / 8

    1229. 

  1229.                 break;

    1230. 

  1230.             case 'arcfour':

    1231. 

  1231.             case 'arcfour128':

    1232. 

  1232.             case 'arcfour256':

    1233. 

  1233.                 $this->encrypt = new Crypt_RC4();

    1234. 

  1234.                 break;

    1235. 

  1235.             case 'none';

    1236. 

  1236.                 //$this->encrypt = new Crypt_Null();

    1237. 

  1237.         }

    1238. 

  1238. 

    1239. 

  1239.         switch ($decrypt) {

    1240. 

  1240.             case '3des-cbc':

    1241. 

  1241.                 $this->decrypt = new Crypt_TripleDES();

    1242. 

  1242.                 break;

    1243. 

  1243.             case '3des-ctr':

    1244. 

  1244.                 $this->decrypt = new Crypt_TripleDES(CRYPT_DES_MODE_CTR);

    1245. 

  1245.                 break;

    1246. 

  1246.             case 'aes256-cbc':

    1247. 

  1247.             case 'aes192-cbc':

    1248. 

  1248.             case 'aes128-cbc':

    1249. 

  1249.                 $this->decrypt = new Crypt_AES();

    1250. 

  1250.                 $this->decrypt_block_size = 16;

    1251. 

  1251.                 break;

    1252. 

  1252.             case 'aes256-ctr':

    1253. 

  1253.             case 'aes192-ctr':

    1254. 

  1254.             case 'aes128-ctr':

    1255. 

  1255.                 $this->decrypt = new Crypt_AES(CRYPT_AES_MODE_CTR);

    1256. 

  1256.                 $this->decrypt_block_size = 16;

    1257. 

  1257.                 break;

    1258. 

  1258.             case 'arcfour':

    1259. 

  1259.             case 'arcfour128':

    1260. 

  1260.             case 'arcfour256':

    1261. 

  1261.                 $this->decrypt = new Crypt_RC4();

    1262. 

  1262.                 break;

    1263. 

  1263.             case 'none';

    1264. 

  1264.                 //$this->decrypt = new Crypt_Null();

    1265. 

  1265.         }

    1266. 

  1266. 

    1267. 

  1267.         $keyBytes = pack('Na*', strlen($keyBytes), $keyBytes);

    1268. 

  1268. 

    1269. 

  1269.         if ($this->encrypt) {

    1270. 

  1270.             $this->encrypt->enableContinuousBuffer();

    1271. 

  1271.             $this->encrypt->disablePadding();

    1272. 

  1272. 

    1273. 

  1273.             $iv = pack('H*', $hash($keyBytes . $this->exchange_hash . 'A' . $this->session_id));

    1274. 

  1274.             while ($this->encrypt_block_size > strlen($iv)) {

    1275. 

  1275.                 $iv.= pack('H*', $hash($keyBytes . $this->exchange_hash . $iv));

    1276. 

  1276.             }

    1277. 

  1277.             $this->encrypt->setIV(substr($iv, 0, $this->encrypt_block_size));

    1278. 

  1278. 

    1279. 

  1279.             $key = pack('H*', $hash($keyBytes . $this->exchange_hash . 'C' . $this->session_id));

    1280. 

  1280.             while ($encryptKeyLength > strlen($key)) {

    1281. 

  1281.                 $key.= pack('H*', $hash($keyBytes . $this->exchange_hash . $key));

    1282. 

  1282.             }

    1283. 

  1283.             $this->encrypt->setKey(substr($key, 0, $encryptKeyLength));

    1284. 

  1284.         }

    1285. 

  1285. 

    1286. 

  1286.         if ($this->decrypt) {

    1287. 

  1287.             $this->decrypt->enableContinuousBuffer();

    1288. 

  1288.             $this->decrypt->disablePadding();

    1289. 

  1289. 

    1290. 

  1290.             $iv = pack('H*', $hash($keyBytes . $this->exchange_hash . 'B' . $this->session_id));

    1291. 

  1291.             while ($this->decrypt_block_size > strlen($iv)) {

    1292. 

  1292.                 $iv.= pack('H*', $hash($keyBytes . $this->exchange_hash . $iv));

    1293. 

  1293.             }

    1294. 

  1294.             $this->decrypt->setIV(substr($iv, 0, $this->decrypt_block_size));

    1295. 

  1295. 

    1296. 

  1296.             $key = pack('H*', $hash($keyBytes . $this->exchange_hash . 'D' . $this->session_id));

    1297. 

  1297.             while ($decryptKeyLength > strlen($key)) {

    1298. 

  1298.                 $key.= pack('H*', $hash($keyBytes . $this->exchange_hash . $key));

    1299. 

  1299.             }

    1300. 

  1300.             $this->decrypt->setKey(substr($key, 0, $decryptKeyLength));

    1301. 

  1301.         }

    1302. 

  1302. 

    1303. 

  1303.         /* The "arcfour128" algorithm is the RC4 cipher, as described in

    1304. 

  1304.            [SCHNEIER], using a 128-bit key.  The first 1536 bytes of keystream

    1305. 

  1305.            generated by the cipher MUST be discarded, and the first byte of the

    1306. 

  1306.            first encrypted packet MUST be encrypted using the 1537th byte of

    1307. 

  1307.            keystream.

    1308. 

  1308. 

    1309. 

  1309.            -- http://tools.ietf.org/html/rfc4345#section-4 */

    1310. 

  1310.         if ($encrypt == 'arcfour128' || $encrypt == 'arcfour256') {

    1311. 

  1311.             $this->encrypt->encrypt(str_repeat("\0", 1536));

    1312. 

  1312.         }

    1313. 

  1313.         if ($decrypt == 'arcfour128' || $decrypt == 'arcfour256') {

    1314. 

  1314.             $this->decrypt->decrypt(str_repeat("\0", 1536));

    1315. 

  1315.         }

    1316. 

  1316. 

    1317. 

  1317.         for ($i = 0; $i < count($mac_algorithms) && !in_array($mac_algorithms[$i], $this->mac_algorithms_client_to_server); $i++);

    1318. 

  1318.         if ($i == count($mac_algorithms)) {

    1319. 

  1319.             user_error('No compatible client to server message authentication algorithms found', E_USER_NOTICE);

    1320. 

  1320.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1321. 

  1321.         }

    1322. 

  1322. 

    1323. 

  1323.         $createKeyLength = 0; // ie. $mac_algorithms[$i] == 'none'

    1324. 

  1324.         switch ($mac_algorithms[$i]) {

    1325. 

  1325.             case 'hmac-sha1':

    1326. 

  1326.                 $this->hmac_create = new Crypt_Hash('sha1');

    1327. 

  1327.                 $createKeyLength = 20;

    1328. 

  1328.                 break;

    1329. 

  1329.             case 'hmac-sha1-96':

    1330. 

  1330.                 $this->hmac_create = new Crypt_Hash('sha1-96');

    1331. 

  1331.                 $createKeyLength = 20;

    1332. 

  1332.                 break;

    1333. 

  1333.             case 'hmac-md5':

    1334. 

  1334.                 $this->hmac_create = new Crypt_Hash('md5');

    1335. 

  1335.                 $createKeyLength = 16;

    1336. 

  1336.                 break;

    1337. 

  1337.             case 'hmac-md5-96':

    1338. 

  1338.                 $this->hmac_create = new Crypt_Hash('md5-96');

    1339. 

  1339.                 $createKeyLength = 16;

    1340. 

  1340.         }

    1341. 

  1341. 

    1342. 

  1342.         for ($i = 0; $i < count($mac_algorithms) && !in_array($mac_algorithms[$i], $this->mac_algorithms_server_to_client); $i++);

    1343. 

  1343.         if ($i == count($mac_algorithms)) {

    1344. 

  1344.             user_error('No compatible server to client message authentication algorithms found', E_USER_NOTICE);

    1345. 

  1345.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1346. 

  1346.         }

    1347. 

  1347. 

    1348. 

  1348.         $checkKeyLength = 0;

    1349. 

  1349.         $this->hmac_size = 0;

    1350. 

  1350.         switch ($mac_algorithms[$i]) {

    1351. 

  1351.             case 'hmac-sha1':

    1352. 

  1352.                 $this->hmac_check = new Crypt_Hash('sha1');

    1353. 

  1353.                 $checkKeyLength = 20;

    1354. 

  1354.                 $this->hmac_size = 20;

    1355. 

  1355.                 break;

    1356. 

  1356.             case 'hmac-sha1-96':

    1357. 

  1357.                 $this->hmac_check = new Crypt_Hash('sha1-96');

    1358. 

  1358.                 $checkKeyLength = 20;

    1359. 

  1359.                 $this->hmac_size = 12;

    1360. 

  1360.                 break;

    1361. 

  1361.             case 'hmac-md5':

    1362. 

  1362.                 $this->hmac_check = new Crypt_Hash('md5');

    1363. 

  1363.                 $checkKeyLength = 16;

    1364. 

  1364.                 $this->hmac_size = 16;

    1365. 

  1365.                 break;

    1366. 

  1366.             case 'hmac-md5-96':

    1367. 

  1367.                 $this->hmac_check = new Crypt_Hash('md5-96');

    1368. 

  1368.                 $checkKeyLength = 16;

    1369. 

  1369.                 $this->hmac_size = 12;

    1370. 

  1370.         }

    1371. 

  1371. 

    1372. 

  1372.         $key = pack('H*', $hash($keyBytes . $this->exchange_hash . 'E' . $this->session_id));

    1373. 

  1373.         while ($createKeyLength > strlen($key)) {

    1374. 

  1374.             $key.= pack('H*', $hash($keyBytes . $this->exchange_hash . $key));

    1375. 

  1375.         }

    1376. 

  1376.         $this->hmac_create->setKey(substr($key, 0, $createKeyLength));

    1377. 

  1377. 

    1378. 

  1378.         $key = pack('H*', $hash($keyBytes . $this->exchange_hash . 'F' . $this->session_id));

    1379. 

  1379.         while ($checkKeyLength > strlen($key)) {

    1380. 

  1380.             $key.= pack('H*', $hash($keyBytes . $this->exchange_hash . $key));

    1381. 

  1381.         }

    1382. 

  1382.         $this->hmac_check->setKey(substr($key, 0, $checkKeyLength));

    1383. 

  1383. 

    1384. 

  1384.         for ($i = 0; $i < count($compression_algorithms) && !in_array($compression_algorithms[$i], $this->compression_algorithms_server_to_client); $i++);

    1385. 

  1385.         if ($i == count($compression_algorithms)) {

    1386. 

  1386.             user_error('No compatible server to client compression algorithms found', E_USER_NOTICE);

    1387. 

  1387.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1388. 

  1388.         }

    1389. 

  1389.         $this->decompress = $compression_algorithms[$i] == 'zlib';

    1390. 

  1390. 

    1391. 

  1391.         for ($i = 0; $i < count($compression_algorithms) && !in_array($compression_algorithms[$i], $this->compression_algorithms_client_to_server); $i++);

    1392. 

  1392.         if ($i == count($compression_algorithms)) {

    1393. 

  1393.             user_error('No compatible client to server compression algorithms found', E_USER_NOTICE);

    1394. 

  1394.             return $this->_disconnect(NET_SSH2_DISCONNECT_KEY_EXCHANGE_FAILED);

    1395. 

  1395.         }

    1396. 

  1396.         $this->compress = $compression_algorithms[$i] == 'zlib';

    1397. 

  1397. 

    1398. 

  1398.         return true;

    1399. 

  1399.     }

    1400. 

  1400. 

    1401. 

  1401.     /**

    1402. 

  1402.      * Login

    1403. 

  1403.      *

    1404. 

  1404.      * The $password parameter can be a plaintext password or a Crypt_RSA object.

    1405. 

  1405.      *

    1406. 

  1406.      * @param String $username

    1407. 

  1407.      * @param optional String $password

    1408. 

  1408.      * @return Boolean

    1409. 

  1409.      * @access public

    1410. 

  1410.      * @internal It might be worthwhile, at some point, to protect against {@link http://tools.ietf.org/html/rfc4251#section-9.3.9 traffic analysis}

    1411. 

  1411.      *           by sending dummy SSH_MSG_IGNORE messages.

    1412. 

  1412.      */

    1413. 

  1413.     function login($username, $password = '')

    1414. 

  1414.     {

    1415. 

  1415.         if (!($this->bitmap & NET_SSH2_MASK_CONSTRUCTOR)) {

    1416. 

  1416.             return false;

    1417. 

  1417.         }

    1418. 

  1418. 

    1419. 

  1419.         $packet = pack('CNa*',

    1420. 

  1420.             NET_SSH2_MSG_SERVICE_REQUEST, strlen('ssh-userauth'), 'ssh-userauth'

    1421. 

  1421.         );

    1422. 

  1422. 

    1423. 

  1423.         i…
    1424.

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