开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
SSH2Connection.cs
资源名称：Terminal_Control_jan_2009.zip　[点击查看]
上传用户：szltgg
上传日期：2019-05-16
资源大小：604k
文件大小：38k
源码类别：

Telnet服务器

开发平台：

C#

SSH2Connection.cs：源码内容
  1. /*
  2.  Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3.  This file is a part of the Granados SSH Client Library that is subject to
  4.  the license included in the distributed package.
  5.  You may not use this file except in compliance with the license.
  7.  $Id: SSH2Connection.cs,v 1.2 2005/04/20 08:58:56 okajima Exp $
  8. */
  9. using System;
  10. using System.Collections;
  11. using System.IO;
  12. using System.Threading;
  13. using System.Diagnostics;
  14. using System.Net.Sockets;
  15. using System.Text;
  16. using System.Security.Cryptography;
  18. using Granados.PKI;
  19. using Granados.SSHC;
  20. using Granados.Toolkit;
  22. namespace Granados.SSHCV2
  23. {
  24. public sealed class SSH2Connection : SSHConnection {
  26. //packet count for transmission and reception
  27. private int _tSequence;
  29. //MAC for transmission and reception
  30. private MAC _tMAC;
  31. private SSH2PacketBuilder _packetBuilder;
  33. //server info
  34. private SSH2ConnectionInfo _cInfo;
  36. private bool _waitingForPortForwardingResponse;
  38. private KeyExchanger _asyncKeyExchanger;
  40. public SSH2Connection(SSHConnectionParameter param, ISSHConnectionEventReceiver r, string serverversion, string clientversion) : base(param, r) {
  41. _cInfo = new SSH2ConnectionInfo();
  42. _cInfo._serverVersionString = serverversion;
  43. _cInfo._clientVersionString = clientversion;
  45. _packetBuilder = new SSH2PacketBuilder(new SynchronizedSSH2PacketHandler());
  46. }
  47. internal override IByteArrayHandler PacketBuilder {
  48. get {
  49. return _packetBuilder;
  50. }
  51. }
  52. public override SSHConnectionInfo ConnectionInfo {
  53. get {
  54. return _cInfo;
  55. }
  56. }
  58. internal override AuthenticationResult Connect(AbstractSocket s) {
  59. _stream = s;
  61. KeyExchanger kex = new KeyExchanger(this, null);
  62. if(!kex.SynchronousKexExchange()) {
  63. _stream.Close();
  64. return AuthenticationResult.Failure;
  65. }
  66. //Step3 user authentication
  67. ServiceRequest("ssh-userauth");
  68. _authenticationResult = UserAuth();
  69. return _authenticationResult;
  70. }
  73. private void ServiceRequest(string servicename) {
  74. SSH2DataWriter wr = new SSH2DataWriter();
  75. wr.WritePacketType(PacketType.SSH_MSG_SERVICE_REQUEST);
  76. wr.Write(servicename);
  77. TransmitPacket(wr.ToByteArray());
  79. byte[] response = ReceivePacket().Data;
  80. SSH2DataReader re = new SSH2DataReader(response);
  81. PacketType t = re.ReadPacketType();
  82. if(t!=PacketType.SSH_MSG_SERVICE_ACCEPT) {
  83. throw new SSHException("service establishment failed "+t);
  84. }
  86. string s = Encoding.ASCII.GetString(re.ReadString());
  87. if(servicename!=s)
  88. throw new SSHException("protocol error");
  89. }
  91. private AuthenticationResult UserAuth() {
  92. string sn = "ssh-connection"; 
  94. SSH2DataWriter wr = new SSH2DataWriter();
  95. wr.WritePacketType(PacketType.SSH_MSG_USERAUTH_REQUEST);
  96. wr.Write(_param.UserName);
  97. if(_param.AuthenticationType==AuthenticationType.Password) {
  98. //Password authentication
  99. wr.Write(sn); 
  100. wr.Write("password");
  101. wr.Write(false);
  102. wr.Write(_param.Password);
  103. }
  104. else if(_param.AuthenticationType==AuthenticationType.KeyboardInteractive) {
  105. wr.Write(sn); 
  106. wr.Write("keyboard-interactive");
  107. wr.Write(""); //lang
  108. wr.Write(""); //submethod
  109. }
  110. else {
  111. //public key authentication
  112. SSH2UserAuthKey kp = SSH2UserAuthKey.FromSECSHStyleFile(_param.IdentityFile, _param.Password);
  113. SSH2DataWriter signsource = new SSH2DataWriter();
  114. signsource.WriteAsString(_sessionID);
  115. signsource.WritePacketType(PacketType.SSH_MSG_USERAUTH_REQUEST);
  116. signsource.Write(_param.UserName);
  117. signsource.Write(sn);
  118. signsource.Write("publickey");
  119. signsource.Write(true);
  120. signsource.Write(SSH2Util.PublicKeyAlgorithmName(kp.Algorithm));
  121. signsource.WriteAsString(kp.GetPublicKeyBlob());
  123. SSH2DataWriter signpack = new SSH2DataWriter();
  124. signpack.Write(SSH2Util.PublicKeyAlgorithmName(kp.Algorithm));
  125. signpack.WriteAsString(kp.Sign(signsource.ToByteArray()));
  127. wr.Write(sn);
  128. wr.Write("publickey");
  129. wr.Write(true);
  130. wr.Write(SSH2Util.PublicKeyAlgorithmName(kp.Algorithm));
  131. wr.WriteAsString(kp.GetPublicKeyBlob());
  132. wr.WriteAsString(signpack.ToByteArray());
  133. }
  134. TransmitPacket(wr.ToByteArray());
  136. _authenticationResult = ProcessAuthenticationResponse();
  137. if(_authenticationResult==AuthenticationResult.Failure)
  138. throw new SSHException(Strings.GetString("AuthenticationFailed"));
  139. return _authenticationResult;
  140. }
  141. private AuthenticationResult ProcessAuthenticationResponse() {
  142. do {
  143. SSH2DataReader response = new SSH2DataReader(ReceivePacket().Data);
  144. PacketType h = response.ReadPacketType();
  145. if(h==PacketType.SSH_MSG_USERAUTH_FAILURE) {
  146. string msg = Encoding.ASCII.GetString(response.ReadString());
  147. return AuthenticationResult.Failure;
  148. }
  149. else if(h==PacketType.SSH_MSG_USERAUTH_BANNER) {
  150. Debug.WriteLine("USERAUTH_BANNER");
  151. }
  152. else if(h==PacketType.SSH_MSG_USERAUTH_SUCCESS) {
  153. _packetBuilder.Handler = new CallbackSSH2PacketHandler(this);
  154. return AuthenticationResult.Success; //successfully exit
  155. }
  156. else if(h==PacketType.SSH_MSG_USERAUTH_INFO_REQUEST) {
  157. string name = Encoding.ASCII.GetString(response.ReadString());
  158. string inst = Encoding.ASCII.GetString(response.ReadString());
  159. string lang = Encoding.ASCII.GetString(response.ReadString());
  160. int num = response.ReadInt32();
  161. string[] prompts = new string[num];
  162. for(int i=0; i<num; i++) {
  163. prompts[i] = Encoding.ASCII.GetString(response.ReadString());
  164. bool echo = response.ReadBool();
  165. }
  166. _eventReceiver.OnAuthenticationPrompt(prompts);
  167. return AuthenticationResult.Prompt;
  168. }
  169. else
  170. throw new SSHException("protocol error: unexpected packet type "+h);
  171. } while(true);
  172. }
  173. public AuthenticationResult DoKeyboardInteractiveAuth(string[] input) {
  174. if(_param.AuthenticationType!=AuthenticationType.KeyboardInteractive)
  175. throw new SSHException("DoKeyboardInteractiveAuth() must be called with keyboard-interactive authentication");
  176. SSH2DataWriter re = new SSH2DataWriter();
  177. re.WritePacketType(PacketType.SSH_MSG_USERAUTH_INFO_RESPONSE);
  178. re.Write(input.Length);
  179. foreach(string t in input)
  180. re.Write(t);
  181. TransmitPacket(re.ToByteArray());
  183. _authenticationResult = ProcessAuthenticationResponse();
  184. //try again on failure
  185. if(_authenticationResult==AuthenticationResult.Failure) {
  186. SSH2DataWriter wr = new SSH2DataWriter();
  187. wr.WritePacketType(PacketType.SSH_MSG_USERAUTH_REQUEST);
  188. wr.Write(_param.UserName);
  189. wr.Write("ssh-connection"); 
  190. wr.Write("keyboard-interactive");
  191. wr.Write(""); //lang
  192. wr.Write(""); //submethod
  193. TransmitPacket(wr.ToByteArray());
  194. _authenticationResult = ProcessAuthenticationResponse();
  195. }
  196. return _authenticationResult;
  197. }
  199. public override SSHChannel OpenShell(ISSHChannelEventReceiver receiver) {
  200. //open channel
  201. SSH2DataWriter wr = new SSH2DataWriter();
  202. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN);
  203. wr.Write("session");
  204. int local_channel = this.RegisterChannelEventReceiver(null, receiver)._localID;
  206. wr.Write(local_channel);
  207. wr.Write(_param.WindowSize); //initial window size
  208. int windowsize = _param.WindowSize;
  209. wr.Write(_param.MaxPacketSize); //max packet size
  210. SSH2Channel channel = new SSH2Channel(this, ChannelType.Shell, local_channel);
  211. TransmitPacket(wr.ToByteArray());
  213. return channel;
  214. }
  216. public override SSHChannel ForwardPort(ISSHChannelEventReceiver receiver, string remote_host, int remote_port, string originator_host, int originator_port) {
  217. SSH2DataWriter wr = new SSH2DataWriter();
  218. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN);
  219. wr.Write("direct-tcpip");
  220. int local_id = RegisterChannelEventReceiver(null, receiver)._localID;
  221. wr.Write(local_id);
  222. wr.Write(_param.WindowSize); //initial window size
  223. int windowsize = _param.WindowSize;
  224. wr.Write(_param.MaxPacketSize); //max packet size
  225. wr.Write(remote_host);
  226. wr.Write(remote_port);
  227. wr.Write(originator_host);
  228. wr.Write(originator_port);
  230. SSH2Channel channel = new SSH2Channel(this, ChannelType.ForwardedLocalToRemote, local_id);
  232. TransmitPacket(wr.ToByteArray());
  234. return channel;
  235. }
  237. public override void ListenForwardedPort(string allowed_host, int bind_port) {
  238. SSH2DataWriter wr = new SSH2DataWriter();
  239. wr.WritePacketType(PacketType.SSH_MSG_GLOBAL_REQUEST);
  240. wr.Write("tcpip-forward");
  241. wr.Write(true);
  242. wr.Write(allowed_host);
  243. wr.Write(bind_port);
  245. _waitingForPortForwardingResponse = true;
  246. TransmitPacket(wr.ToByteArray());
  247. }
  249. public override void CancelForwardedPort(string host, int port) {
  250. SSH2DataWriter wr = new SSH2DataWriter();
  251. wr.WritePacketType(PacketType.SSH_MSG_GLOBAL_REQUEST);
  252. wr.Write("cancel-tcpip-forward");
  253. wr.Write(true);
  254. wr.Write(host);
  255. wr.Write(port);
  256. TransmitPacket(wr.ToByteArray());
  257. }
  259. private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH2DataReader reader) {
  260. string method = Encoding.ASCII.GetString(reader.ReadString());
  262. int remote_channel = reader.ReadInt32();
  263. int window_size = reader.ReadInt32(); //skip initial window size
  264. int servermaxpacketsize = reader.ReadInt32();
  265. string host = Encoding.ASCII.GetString(reader.ReadString());
  266. int port = reader.ReadInt32();
  267. string originator_ip = Encoding.ASCII.GetString(reader.ReadString());
  268. int originator_port = reader.ReadInt32();
  270. PortForwardingCheckResult r = receiver.CheckPortForwardingRequest(host,port,originator_ip,originator_port);
  271. SSH2DataWriter wr = new SSH2DataWriter();
  272. if(r.allowed) {
  273. //send OPEN_CONFIRMATION
  274. SSH2Channel channel = new SSH2Channel(this, ChannelType.ForwardedRemoteToLocal, RegisterChannelEventReceiver(null, r.channel)._localID, remote_channel, servermaxpacketsize);
  275. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
  276. wr.Write(remote_channel);
  277. wr.Write(channel.LocalChannelID);
  278. wr.Write(_param.WindowSize); //initial window size
  279. wr.Write(_param.MaxPacketSize); //max packet size
  280. receiver.EstablishPortforwarding(r.channel, channel);
  281. }
  282. else {
  283. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE);
  284. wr.Write(remote_channel);
  285. wr.Write(r.reason_code);
  286. wr.Write(r.reason_message);
  287. wr.Write(""); //lang tag
  288. }
  289. TransmitPacket(wr.ToByteArray());
  290. }
  292. internal SSH2Packet TransmitPacket(byte[] payload) {
  293. lock(_tLockObject) { 
  294. SSH2Packet p = SSH2Packet.FromPlainPayload(payload, _tCipher==null? 8 : _tCipher.BlockSize, _param.Random);
  295. if(_tMAC!=null) p.CalcHash(_tMAC, _tSequence);
  297. _tSequence++;
  298. p.WriteTo(_stream, _tCipher);
  299. return p;
  300. }
  301. }
  303. //synchronous reception
  304. internal SSH2Packet ReceivePacket() {
  306. while(true) {
  307. SSH2Packet p = null;
  308. SynchronizedSSH2PacketHandler handler = (SynchronizedSSH2PacketHandler)_packetBuilder.Handler;
  309. if(!handler.HasPacket) {
  310. handler.Wait();
  311. if(handler.State==ReceiverState.Error)
  312. throw new SSHException(handler.ErrorMessage);
  313. else if(handler.State==ReceiverState.Closed)
  314. throw new SSHException("socket closed");
  315. }
  316. p = handler.PopPacket();
  318. SSH2DataReader r = new SSH2DataReader(p.Data);
  319. PacketType pt = r.ReadPacketType();
  320. if(pt==PacketType.SSH_MSG_IGNORE) {
  321. if(_eventReceiver!=null) _eventReceiver.OnIgnoreMessage(r.ReadString());
  322. }
  323. else if(pt==PacketType.SSH_MSG_DEBUG) {
  324. bool f = r.ReadBool();
  325. if(_eventReceiver!=null) _eventReceiver.OnDebugMessage(f, r.ReadString());
  326. }
  327. else
  328. return p;
  329. }
  330. }
  331. internal void AsyncReceivePacket(SSH2Packet packet) {
  332. try {
  333. ProcessPacket(packet);
  334. }
  335. catch(Exception ex) {
  336. //Debug.WriteLine(ex.StackTrace);
  337. if(!_closed)
  338. _eventReceiver.OnError(ex, ex.Message);
  339. }
  340. }
  342. private bool ProcessPacket(SSH2Packet packet) {
  343. SSH2DataReader r = new SSH2DataReader(packet.Data);
  344. PacketType pt = r.ReadPacketType();
  345. //Debug.WriteLine("ProcessPacket pt="+pt);
  347. if(pt==PacketType.SSH_MSG_DISCONNECT) {
  348. int errorcode = r.ReadInt32();
  349. //string description = Encoding.ASCII.GetString(r.ReadString());
  350. _eventReceiver.OnConnectionClosed();
  351. return false;
  352. }
  353. else if(_waitingForPortForwardingResponse) {
  354. if(pt!=PacketType.SSH_MSG_REQUEST_SUCCESS)
  355. _eventReceiver.OnUnknownMessage((byte)pt, r.Image);
  356. _waitingForPortForwardingResponse = false;
  357. return true;
  358. }
  359. else if(pt==PacketType.SSH_MSG_CHANNEL_OPEN) {
  360. ProcessPortforwardingRequest(_eventReceiver, r);
  361. return true;
  362. }
  363. else if(pt>=PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION && pt<=PacketType.SSH_MSG_CHANNEL_FAILURE) {
  364. int local_channel = r.ReadInt32();
  365. ChannelEntry e = FindChannelEntry(local_channel);
  366. if(e!=null) //throw new SSHException("Unknown channel "+local_channel);
  367. ((SSH2Channel)e._channel).ProcessPacket(e._receiver, pt, 5+r.Rest, r);
  368. else
  369. Debug.WriteLine("unexpected channel pt="+pt+" local_channel="+local_channel.ToString());
  370. return true;
  371. }
  372. else if(pt==PacketType.SSH_MSG_IGNORE) {
  373. _eventReceiver.OnIgnoreMessage(r.ReadString());
  374. return true;
  375. }
  376. else if(_asyncKeyExchanger!=null) {
  377. _asyncKeyExchanger.AsyncProcessPacket(packet);
  378. return true;
  379. }
  380. else if(pt==PacketType.SSH_MSG_KEXINIT) {
  381. //Debug.WriteLine("Host sent KEXINIT");
  382. _asyncKeyExchanger = new KeyExchanger(this, _sessionID);
  383. _asyncKeyExchanger.AsyncProcessPacket(packet);
  384. return true;
  385. }
  386. else {
  387. _eventReceiver.OnUnknownMessage((byte)pt, r.Image);
  388. return false;
  389. }
  390. }
  392. public override void Disconnect(string msg) {
  393. if(_closed) return;
  394. SSH2DataWriter wr = new SSH2DataWriter();
  395. wr.WritePacketType(PacketType.SSH_MSG_DISCONNECT);
  396. wr.Write(0);
  397. wr.Write(msg);
  398. wr.Write(""); //language
  399. TransmitPacket(wr.ToByteArray());
  400. _stream.Flush();
  401. _closed = true;
  402. _stream.Close();
  403. }
  405. public override void Close() {
  406. if(_closed) return;
  407. _closed = true;
  408. _stream.Close();
  409. } 
  410. public override void SendIgnorableData(string msg) {
  411. SSH2DataWriter w = new SSH2DataWriter();
  412. w.WritePacketType(PacketType.SSH_MSG_IGNORE);
  413. w.Write(msg);
  414. TransmitPacket(w.ToByteArray());
  415. }
  416. public void ReexchangeKeys() {
  417. _asyncKeyExchanger = new KeyExchanger(this, _sessionID);
  418. _asyncKeyExchanger.AsyncStartReexchange();
  419. }
  421. internal void LockCommunication() {
  422. _packetBuilder.SetSignal(false);
  423. }
  424. internal void UnlockCommunication() {
  425. _packetBuilder.SetSignal(true);
  426. }
  427. internal void RefreshKeys(byte[] sessionID, Cipher tc, Cipher rc, MAC tm, MAC rm) {
  428. _sessionID = sessionID;
  429. _tCipher = tc;
  430. _tMAC = tm;
  431. _packetBuilder.SetCipher(rc, _param.CheckMACError? rm : null);
  432. _asyncKeyExchanger = null;
  433. }
  435. }
  437. public class SSH2Channel : SSHChannel {
  438. //channel property
  439. protected int _windowSize;
  440. protected int _leftWindowSize;
  441. protected int _serverMaxPacketSize;
  442. protected int _allowedDataSize;
  444. //negotiation status
  445. protected int _negotiationStatus;
  447. public SSH2Channel(SSHConnection con, ChannelType type, int local_id) : base(con, type, local_id) {
  448. _windowSize = _leftWindowSize = con.Param.WindowSize;
  449. _negotiationStatus = type==ChannelType.Shell? 3 : type==ChannelType.ForwardedLocalToRemote? 1 : type==ChannelType.Session? 1 : 0;
  450. }
  451. public SSH2Channel(SSHConnection con, ChannelType type, int local_id, int remote_id, int maxpacketsize) : base(con, type, local_id) {
  452. _windowSize = _leftWindowSize = con.Param.WindowSize;
  453. Debug.Assert(type==ChannelType.ForwardedRemoteToLocal);
  454. _remoteID = remote_id;
  455. _serverMaxPacketSize = maxpacketsize;
  456. _negotiationStatus = 0;
  457. }
  459. public override void ResizeTerminal(int width, int height, int pixel_width, int pixel_height) {
  460. SSH2DataWriter wr = new SSH2DataWriter();
  461. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_REQUEST);
  462. wr.Write(_remoteID);
  463. wr.Write("window-change");
  464. wr.Write(false);
  465. wr.Write(width);
  466. wr.Write(height);
  467. wr.Write(pixel_width); //no graphics
  468. wr.Write(pixel_height);
  469. TransmitPacket(wr.ToByteArray());
  470. }
  471. public override void Transmit(byte[] data) {
  472. //!!it is better idea that we wait a WINDOW_ADJUST if the left size is lack
  473. SSH2DataWriter wr = new SSH2DataWriter();
  474. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_DATA);
  475. wr.Write(_remoteID);
  476. wr.WriteAsString(data);
  478. TransmitPacket(wr.ToByteArray());
  479. }
  480. public override void Transmit(byte[] data, int offset, int length) {
  481. SSH2DataWriter wr = new SSH2DataWriter();
  482. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_DATA);
  483. wr.Write(_remoteID);
  484. wr.WriteAsString(data, offset, length);
  486. TransmitPacket(wr.ToByteArray());
  487. }
  489. public override void SendEOF() {
  490. if(_connection.IsClosed) return;
  491. SSH2DataWriter wr = new SSH2DataWriter();
  492. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_EOF);
  493. wr.Write(_remoteID);
  494. TransmitPacket(wr.ToByteArray());
  495. }
  498. public override void Close() {
  499. if(_connection.IsClosed) return;
  500. SSH2DataWriter wr = new SSH2DataWriter();
  501. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_CLOSE);
  502. wr.Write(_remoteID);
  503. TransmitPacket(wr.ToByteArray());
  505. }
  507. //maybe this is SSH2 only feature
  508. public void SetEnvironmentVariable(string name, string value) {
  509. SSH2DataWriter wr = new SSH2DataWriter();
  510. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_REQUEST);
  511. wr.Write(_remoteID);
  512. wr.Write("env");
  513. wr.Write(false);
  514. wr.Write(name);
  515. wr.Write(value);
  516. TransmitPacket(wr.ToByteArray());
  517. }
  518. public void SendBreak(int time) {
  519. SSH2DataWriter wr = new SSH2DataWriter();
  520. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_REQUEST);
  521. wr.Write(_remoteID);
  522. wr.Write("break");
  523. wr.Write(true);
  524. wr.Write(time);
  525. TransmitPacket(wr.ToByteArray());
  526. }
  528. internal void ProcessPacket(ISSHChannelEventReceiver receiver, PacketType pt, int data_length, SSH2DataReader re) {
  529. //NOTE: the offset of 're' is next to 'receipiant channel' field
  530. _leftWindowSize -= data_length;
  531. if(pt!=PacketType.SSH_MSG_CHANNEL_EOF && pt!=PacketType.SSH_MSG_CHANNEL_CLOSE) { //window adjust is not necessary if the channel is being closed
  532. while(_leftWindowSize <= _windowSize) {
  533. SSH2DataWriter adj = new SSH2DataWriter();
  534. adj.WritePacketType(PacketType.SSH_MSG_CHANNEL_WINDOW_ADJUST);
  535. adj.Write(_remoteID);
  536. adj.Write(_windowSize);
  537. TransmitPacket(adj.ToByteArray());
  538. _leftWindowSize += _windowSize;
  539. //Debug.WriteLine("Window size is adjusted to " + _leftWindowSize);
  540. }
  541. }
  543. if(pt==PacketType.SSH_MSG_CHANNEL_WINDOW_ADJUST) {
  544. int w = re.ReadInt32();
  545. //some servers may not send SSH_MSG_CHANNEL_WINDOW_ADJUST. 
  546. //it is dangerous to wait this message in send procedure
  547. _allowedDataSize += w;
  548. //Debug.WriteLine(String.Format("Window Adjust +={0}",w));
  549. }
  550. else if(_negotiationStatus!=0) { //when the negotiation is not completed
  551. if(_type==ChannelType.Shell)
  552. OpenShell(receiver, pt, re);
  553. else if(_type==ChannelType.ForwardedLocalToRemote)
  554. ReceivePortForwardingResponse(receiver, pt, re);
  555. else if(_type==ChannelType.Session)
  556. EstablishSession(receiver, pt, re);
  557. }
  558. else {
  559. switch(pt) {
  560. case PacketType.SSH_MSG_CHANNEL_DATA: {
  561. int len = re.ReadInt32();
  562. receiver.OnData(re.Image, re.Offset, len);
  563. }
  564. break;
  565. case PacketType.SSH_MSG_CHANNEL_EXTENDED_DATA: {
  566. int t = re.ReadInt32();
  567. byte[] data = re.ReadString();
  568. receiver.OnExtendedData(t, data);
  569. }
  570. break;
  571. case PacketType.SSH_MSG_CHANNEL_REQUEST: {
  572. string request = Encoding.ASCII.GetString(re.ReadString());
  573. bool reply = re.ReadBool();
  574. if(request=="exit-status") {
  575. int status = re.ReadInt32();
  576. }
  577. else if(reply) { //we reject unknown requests including keep-alive check
  578. SSH2DataWriter wr = new SSH2DataWriter();
  579. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_FAILURE);
  580. wr.Write(_remoteID);
  581. TransmitPacket(wr.ToByteArray());
  582. }
  583. }
  584. break;
  585. case PacketType.SSH_MSG_CHANNEL_EOF:
  586. receiver.OnChannelEOF();
  587. break;
  588. case PacketType.SSH_MSG_CHANNEL_CLOSE:
  589. _connection.UnregisterChannelEventReceiver(_localID);
  590. receiver.OnChannelClosed();
  591. break;
  592. case PacketType.SSH_MSG_CHANNEL_FAILURE:
  593. case PacketType.SSH_MSG_CHANNEL_SUCCESS:
  594. receiver.OnMiscPacket((byte)pt, re.Image, re.Offset, re.Rest);
  595. break;
  596. default:
  597. receiver.OnMiscPacket((byte)pt, re.Image, re.Offset, re.Rest);
  598. Debug.WriteLine("Unknown Packet "+pt);
  599. break;
  600. }
  602. }
  604. }
  606. private void TransmitPacket(byte[] data) {
  607. _allowedDataSize -= data.Length;
  608. ((SSH2Connection)_connection).TransmitPacket(data);
  609. }
  611. private void OpenShell(ISSHChannelEventReceiver receiver, PacketType pt, SSH2DataReader reader) {
  612. if(_negotiationStatus==3) {
  613. if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
  614. if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE)
  615. receiver.OnChannelError(null, "opening channel failed; packet type="+pt);
  616. else {
  617. int errcode = reader.ReadInt32();
  618. string msg = Encoding.ASCII.GetString(reader.ReadString());
  619. receiver.OnChannelError(null, msg);
  620. }
  621. Close();
  622. }
  623. else {
  624. _remoteID = reader.ReadInt32();
  625. _allowedDataSize = reader.ReadInt32();
  626. _serverMaxPacketSize = reader.ReadInt32();
  628. //open pty
  629. SSH2DataWriter wr = new SSH2DataWriter();
  630. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_REQUEST);
  631. wr.Write(_remoteID);
  632. wr.Write("pty-req");
  633. wr.Write(true);
  634. wr.Write(_connection.Param.TerminalName);
  635. wr.Write(_connection.Param.TerminalWidth);
  636. wr.Write(_connection.Param.TerminalHeight);
  637. wr.Write(_connection.Param.TerminalPixelWidth);
  638. wr.Write(_connection.Param.TerminalPixelHeight);
  639. wr.WriteAsString(new byte[0]);
  640. TransmitPacket(wr.ToByteArray());
  642. _negotiationStatus = 2;
  643. }
  644. }
  645. else if(_negotiationStatus==2) {
  646. if(pt!=PacketType.SSH_MSG_CHANNEL_SUCCESS) {
  647. receiver.OnChannelError(null, "opening pty failed");
  648. Close();
  649. }
  650. else {
  651. //open shell
  652. SSH2DataWriter wr = new SSH2DataWriter();
  653. wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_REQUEST);
  654. wr.Write(_remoteID);
  655. wr.Write("shell");
  656. wr.Write(true);
  657. TransmitPacket(wr.ToByteArray());
  659. _negotiationStatus = 1;
  660. }
  661. }
  662. else if(_negotiationStatus==1) {
  663. if(pt!=PacketType.SSH_MSG_CHANNEL_SUCCESS) {
  664. receiver.OnChannelError(null, "Opening shell failed: packet type="+pt.ToString());
  665. Close();
  666. }
  667. else {
  668. receiver.OnChannelReady();
  669. _negotiationStatus = 0; //goal!
  670. }
  671. }
  672. else
  673. Debug.Assert(false);
  674. }
  676. private void ReceivePortForwardingResponse(ISSHChannelEventReceiver receiver, PacketType pt, SSH2DataReader reader) {
  677. if(_negotiationStatus==1) {
  678. if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
  679. if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE)
  680. receiver.OnChannelError(null, "opening channel failed; packet type="+pt);
  681. else {
  682. int errcode = reader.ReadInt32();
  683. string msg = Encoding.ASCII.GetString(reader.ReadString());
  684. receiver.OnChannelError(null, msg);
  685. }
  686. Close();
  687. }
  688. else {
  689. _remoteID = reader.ReadInt32();
  690. _serverMaxPacketSize = reader.ReadInt32();
  691. _negotiationStatus = 0;
  692. receiver.OnChannelReady();
  693. }
  694. }
  695. else
  696. Debug.Assert(false);
  697. }
  698. private void EstablishSession(ISSHChannelEventReceiver receiver, PacketType pt, SSH2DataReader reader) {
  699. if(_negotiationStatus==1) {
  700. if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
  701. if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE)
  702. receiver.OnChannelError(null, "opening channel failed; packet type="+pt);
  703. else {
  704. int remote_id = reader.ReadInt32();
  705. int errcode = reader.ReadInt32();
  706. string msg = Encoding.ASCII.GetString(reader.ReadString());
  707. receiver.OnChannelError(null, msg);
  708. }
  709. Close();
  710. }
  711. else {
  712. _remoteID = reader.ReadInt32();
  713. _serverMaxPacketSize = reader.ReadInt32();
  714. _negotiationStatus = 0;
  715. receiver.OnChannelReady();
  716. }
  717. }
  718. else
  719. Debug.Assert(false);
  720. }
  721. }
  723. internal class KeyExchanger {
  724. private SSH2Connection _con;
  725. private SSHConnectionParameter _param;
  726. private SSH2ConnectionInfo _cInfo;
  727. //payload of KEXINIT message
  728. private byte[] _serverKEXINITPayload;
  729. private byte[] _clientKEXINITPayload;
  731. //true if the host sent KEXINIT first
  732. private bool _startedByHost;
  734. private ManualResetEvent _newKeyEvent;
  736. //status
  737. private enum Status {
  738. INITIAL,
  739. WAIT_KEXINIT,
  740. WAIT_KEXDH_REPLY,
  741. WAIT_NEWKEYS,
  742. FINISHED
  743. }
  744. private Status _status;
  746. private BigInteger _x;
  747. private BigInteger _e;
  748. private BigInteger _k;
  749. private byte[] _hash;
  750. private byte[] _sessionID;
  752. //results
  753. Cipher _rc;
  754. Cipher _tc;
  755. MAC _rm;
  756. MAC _tm;
  758. private void TransmitPacket(byte[] payload) {
  759. _con.TransmitPacket(payload);
  760. }
  762. public KeyExchanger(SSH2Connection con, byte[] sessionID) {
  763. _con = con;
  764. _param = con.Param;
  765. _cInfo = (SSH2ConnectionInfo)con.ConnectionInfo;
  766. _sessionID = sessionID;
  767. _status = Status.INITIAL;
  768. }
  770. public bool SynchronousKexExchange() {
  771. SendKEXINIT();
  772. ProcessKEXINIT(_con.ReceivePacket());
  773. SendKEXDHINIT();
  774. if(!ProcessKEXDHREPLY(_con.ReceivePacket())) return false;
  775. SendNEWKEYS();
  776. ProcessNEWKEYS(_con.ReceivePacket());
  777. return true;
  778. }
  779. public void AsyncStartReexchange() {
  780. _startedByHost = false;
  781. _status = Status.WAIT_KEXINIT;
  782. SendKEXINIT();
  783. }
  784. public void AsyncProcessPacket(SSH2Packet packet) {
  785. switch(_status) {
  786. case Status.INITIAL:
  787. _startedByHost = true;
  788. ProcessKEXINIT(packet);
  789. SendKEXINIT();
  790. SendKEXDHINIT();
  791. break;
  792. case Status.WAIT_KEXINIT:
  793. ProcessKEXINIT(packet);
  794. SendKEXDHINIT();
  795. break;
  796. case Status.WAIT_KEXDH_REPLY:
  797. ProcessKEXDHREPLY(packet);
  798. SendNEWKEYS();
  799. break;
  800. case Status.WAIT_NEWKEYS:
  801. ProcessNEWKEYS(packet);
  802. Debug.Assert(_status==Status.FINISHED);
  803. break;
  804. }
  805. }
  807. private void SendKEXINIT() {
  808. SSH2DataWriter wr = new SSH2DataWriter();
  809. wr.WritePacketType(PacketType.SSH_MSG_KEXINIT);
  810. byte[] cookie = new byte[16];
  811. _param.Random.NextBytes(cookie);
  812. wr.Write(cookie);
  813. wr.Write("diffie-hellman-group1-sha1"); //    kex_algorithms
  814. wr.Write(FormatHostKeyAlgorithmDescription());            //    server_host_key_algorithms
  815. wr.Write(FormatCipherAlgorithmDescription());      //    encryption_algorithms_client_to_server
  816. wr.Write(FormatCipherAlgorithmDescription());      //    encryption_algorithms_server_to_client
  817. wr.Write("hmac-sha1");                  //    mac_algorithms_client_to_server
  818. wr.Write("hmac-sha1");                  //    mac_algorithms_server_to_client
  819. wr.Write("none");                       //    compression_algorithms_client_to_server
  820. wr.Write("none");                       //    compression_algorithms_server_to_client
  821. wr.Write("");                           //    languages_client_to_server
  822. wr.Write("");                           //    languages_server_to_client
  823. wr.Write(false); //Indicates whether a guessed key exchange packet follows
  824. wr.Write(0);       //reserved for future extension
  826. _clientKEXINITPayload = wr.ToByteArray();
  827. _status = Status.WAIT_KEXINIT;
  828. TransmitPacket(_clientKEXINITPayload);
  829. }
  830. private void ProcessKEXINIT(SSH2Packet packet) {
  831. _serverKEXINITPayload = packet.Data;
  832. SSH2DataReader re = new SSH2DataReader(_serverKEXINITPayload);
  833. byte[] head = re.Read(17); //Type and cookie
  834. if(head[0]!=(byte)PacketType.SSH_MSG_KEXINIT) throw new SSHException(String.Format("Server response is not SSH_MSG_KEXINIT but {0}", head[0]));
  835. Encoding enc = Encoding.ASCII;
  837. string kex = enc.GetString(re.ReadString());
  838. _cInfo._supportedKEXAlgorithms = kex;
  839. CheckAlgorithmSupport("keyexchange", kex, "diffie-hellman-group1-sha1");
  841. string host_key = enc.GetString(re.ReadString());
  842. _cInfo._supportedHostKeyAlgorithms = host_key;
  843. _cInfo._algorithmForHostKeyVerification = DecideHostKeyAlgorithm(host_key);
  845. string enc_cs = enc.GetString(re.ReadString());
  846. _cInfo._supportedCipherAlgorithms = enc_cs;
  847. _cInfo._algorithmForTransmittion = DecideCipherAlgorithm(enc_cs);
  849. string enc_sc = enc.GetString(re.ReadString());
  850. _cInfo._algorithmForReception = DecideCipherAlgorithm(enc_sc);
  852. string mac_cs = enc.GetString(re.ReadString());
  853. CheckAlgorithmSupport("mac", mac_cs, "hmac-sha1");
  855. string mac_sc = enc.GetString(re.ReadString());
  856. CheckAlgorithmSupport("mac", mac_sc, "hmac-sha1");
  858. string comp_cs = enc.GetString(re.ReadString());
  859. CheckAlgorithmSupport("compression", comp_cs, "none");
  860. string comp_sc = enc.GetString(re.ReadString());
  861. CheckAlgorithmSupport("compression", comp_sc, "none");
  863. string lang_cs = enc.GetString(re.ReadString());
  864. string lang_sc = enc.GetString(re.ReadString());
  865. bool flag = re.ReadBool();
  866. int reserved = re.ReadInt32();
  867. Debug.Assert(re.Rest==0);
  868. if(flag) throw new SSHException("Algorithm negotiation failed"); 
  869. }
  872. private void SendKEXDHINIT() {
  873. //Round1 computes and sends [e]
  874. byte[] sx = new byte[16];
  875. _param.Random.NextBytes(sx);
  876. _x = new BigInteger(sx);
  877. _e = new BigInteger(2).modPow(_x, DH_PRIME);
  878. SSH2DataWriter wr = new SSH2DataWriter();
  879. wr.WritePacketType(PacketType.SSH_MSG_KEXDH_INIT);
  880. wr.Write(_e);
  881. _status = Status.WAIT_KEXDH_REPLY;
  882. TransmitPacket(wr.ToByteArray());
  883. }
  884. private bool ProcessKEXDHREPLY(SSH2Packet packet) {
  885. //Round2 receives response
  886. SSH2DataReader re = new SSH2DataReader(packet.Data);
  887. PacketType h = re.ReadPacketType();
  888. if(h!=PacketType.SSH_MSG_KEXDH_REPLY) throw new SSHException(String.Format("KeyExchange response is not KEXDH_REPLY but {0}", h));
  889. byte[] key_and_cert = re.ReadString();
  890. BigInteger f = re.ReadMPInt();
  891. byte[] signature = re.ReadString();
  892. Debug.Assert(re.Rest==0);
  894. //Round3 calc hash H
  895. SSH2DataWriter wr = new SSH2DataWriter();
  896. _k = f.modPow(_x, DH_PRIME);
  897. wr = new SSH2DataWriter();
  898. wr.Write(_cInfo._clientVersionString);
  899. wr.Write(_cInfo._serverVersionString);
  900. wr.WriteAsString(_clientKEXINITPayload);
  901. wr.WriteAsString(_serverKEXINITPayload);
  902. wr.WriteAsString(key_and_cert);
  903. wr.Write(_e);
  904. wr.Write(f);
  905. wr.Write(_k);
  906. _hash = new SHA1CryptoServiceProvider().ComputeHash(wr.ToByteArray());
  908. if(!VerifyHostKey(key_and_cert, signature, _hash)) return false;
  910. //Debug.WriteLine("hash="+DebugUtil.DumpByteArray(hash));
  911. if(_sessionID==null) _sessionID = _hash;
  912. return true;
  913. }
  914. private void SendNEWKEYS() {
  915. _status = Status.WAIT_NEWKEYS;
  916. _newKeyEvent = new ManualResetEvent(false);
  917. TransmitPacket(new byte[1] {(byte)PacketType.SSH_MSG_NEWKEYS});
  919. //establish Ciphers
  920. _tc = CipherFactory.CreateCipher(SSHProtocol.SSH2, _cInfo._algorithmForTransmittion,
  921. DeriveKey(_k, _hash, 'C', CipherFactory.GetKeySize(_cInfo._algorithmForTransmittion)), DeriveKey(_k, _hash, 'A', CipherFactory.GetBlockSize(_cInfo._algorithmForTransmittion)));
  922. _rc = CipherFactory.CreateCipher(SSHProtocol.SSH2, _cInfo._algorithmForReception,
  923. DeriveKey(_k, _hash, 'D', CipherFactory.GetKeySize(_cInfo._algorithmForReception)), DeriveKey(_k, _hash, 'B', CipherFactory.GetBlockSize(_cInfo._algorithmForReception)));
  925. //establish MACs
  926. MACAlgorithm ma = MACAlgorithm.HMACSHA1;
  927. _tm = MACFactory.CreateMAC(MACAlgorithm.HMACSHA1, DeriveKey(_k, _hash, 'E', MACFactory.GetSize(ma)));
  928. _rm = MACFactory.CreateMAC(MACAlgorithm.HMACSHA1, DeriveKey(_k, _hash, 'F', MACFactory.GetSize(ma)));
  929. _newKeyEvent.Set();
  930. }
  931. private void ProcessNEWKEYS(SSH2Packet packet) {
  932. //confirms new key
  933. try {
  934. byte[] response = packet.Data;
  935. if(response.Length!=1 || response[0]!=(byte)PacketType.SSH_MSG_NEWKEYS) throw new SSHException("SSH_MSG_NEWKEYS failed");
  937. _newKeyEvent.WaitOne();
  938. _newKeyEvent.Close();
  939. _con.LockCommunication();
  940. _con.RefreshKeys(_sessionID, _tc, _rc, _tm, _rm);
  941. _status = Status.FINISHED;
  942. }
  943. finally {
  944. _con.UnlockCommunication();
  945. }
  946. }
  948. private bool VerifyHostKey(byte[] K_S, byte[] signature, byte[] hash) {
  949. SSH2DataReader re1 = new SSH2DataReader(K_S);
  950. string algorithm = Encoding.ASCII.GetString(re1.ReadString());
  951. if(algorithm!=SSH2Util.PublicKeyAlgorithmName(_cInfo._algorithmForHostKeyVerification))
  952. throw new SSHException("Protocol Error: Host Key Algorithm Mismatch");
  954. SSH2DataReader re2 = new SSH2DataReader(signature);
  955. algorithm = Encoding.ASCII.GetString(re2.ReadString());
  956. if(algorithm!=SSH2Util.PublicKeyAlgorithmName(_cInfo._algorithmForHostKeyVerification))
  957. throw new SSHException("Protocol Error: Host Key Algorithm Mismatch");
  958. byte[] sigbody = re2.ReadString();
  959. Debug.Assert(re2.Rest==0);
  961. if(_cInfo._algorithmForHostKeyVerification==PublicKeyAlgorithm.RSA)
  962. VerifyHostKeyByRSA(re1, sigbody, hash);
  963. else if(_cInfo._algorithmForHostKeyVerification==PublicKeyAlgorithm.DSA)
  964. VerifyHostKeyByDSS(re1, sigbody, hash);
  965. else
  966. throw new SSHException("Bad host key algorithm "+_cInfo._algorithmForHostKeyVerification);
  968. //ask the client whether he accepts the host key
  969. if(!_startedByHost && _param.KeyCheck!=null && !_param.KeyCheck(_cInfo))
  970. return false;
  971. else
  972. return true;
  973. }
  975. private void VerifyHostKeyByRSA(SSH2DataReader pubkey, byte[] sigbody, byte[] hash) {
  976. BigInteger exp = pubkey.ReadMPInt();
  977. BigInteger mod = pubkey.ReadMPInt();
  978. Debug.Assert(pubkey.Rest==0);
  980. //Debug.WriteLine(exp.ToHexString());
  981. //Debug.WriteLine(mod.ToHexString());
  983. RSAPublicKey pk = new RSAPublicKey(exp, mod);
  984. pk.VerifyWithSHA1(sigbody, new SHA1CryptoServiceProvider().ComputeHash(hash));
  985. _cInfo._hostkey = pk;
  986. }
  988. private void VerifyHostKeyByDSS(SSH2DataReader pubkey, byte[] sigbody, byte[] hash) {
  989. BigInteger p = pubkey.ReadMPInt();
  990. BigInteger q = pubkey.ReadMPInt();
  991. BigInteger g = pubkey.ReadMPInt();
  992. BigInteger y = pubkey.ReadMPInt();
  993. Debug.Assert(pubkey.Rest==0);
  995. //Debug.WriteLine(p.ToHexString());
  996. //Debug.WriteLine(q.ToHexString());
  997. //Debug.WriteLine(g.ToHexString());
  998. //Debug.WriteLine(y.ToHexString());
  1001. DSAPublicKey pk = new DSAPublicKey(p,g,q,y);
  1002. pk.Verify(sigbody, new SHA1CryptoServiceProvider().ComputeHash(hash));
  1003. _cInfo._hostkey = pk;
  1004. }
  1006. private byte[] DeriveKey(BigInteger key, byte[] hash, char ch, int length) {
  1007. byte[] result = new byte[length];
  1009. SSH2DataWriter wr = new SSH2DataWriter();
  1010. wr.Write(key);
  1011. wr.Write(hash);
  1012. wr.Write((byte)ch);
  1013. wr.Write(_sessionID);
  1014. byte[] h1 = new SHA1CryptoServiceProvider().ComputeHash(wr.ToByteArray());
  1015. if(h1.Length >= length) {
  1016. Array.Copy(h1, 0, result, 0, length);
  1017. return result;
  1018. }
  1019. else {
  1020. wr = new SSH2DataWriter();
  1021. wr.Write(key);
  1022. wr.Write(_sessionID);
  1023. wr.Write(h1);
  1024. byte[] h2 = new SHA1CryptoServiceProvider().ComputeHash(wr.ToByteArray());
  1025. if(h1.Length+h2.Length >= length) {
  1026. Array.Copy(h1, 0, result, 0, h1.Length);
  1027. Array.Copy(h2, 0, result, h1.Length, length-h1.Length);
  1028. return result;
  1029. }
  1030. else
  1031. throw new SSHException("necessary key length is too big"); //long key is not supported
  1032. }
  1033. }
  1035. private static void CheckAlgorithmSupport(string title, string data, string algorithm_name) {
  1036. string[] t = data.Split(',');
  1037. foreach(string s in t) {
  1038. if(s==algorithm_name) return; //found!
  1039. }
  1040. throw new SSHException("Server does not support "+algorithm_name+" for "+title);
  1041. }
  1042. private PublicKeyAlgorithm DecideHostKeyAlgorithm(string data) {
  1043. string[] t = data.Split(',');
  1044. foreach(PublicKeyAlgorithm a in _param.PreferableHostKeyAlgorithms) {
  1045. if(SSHUtil.ContainsString(t, SSH2Util.PublicKeyAlgorithmName(a))) {
  1046. return a;
  1047. }
  1048. }
  1049. throw new SSHException("The negotiation of host key verification algorithm is failed");
  1050. }
  1051. private CipherAlgorithm DecideCipherAlgorithm(string data) {
  1052. string[] t = data.Split(',');
  1053. foreach(CipherAlgorithm a in _param.PreferableCipherAlgorithms) {
  1054. if(SSHUtil.ContainsString(t, CipherFactory.AlgorithmToSSH2Name(a))) {
  1055. return a;
  1056. }
  1057. }
  1058. throw new SSHException("The negotiation of encryption algorithm is failed");
  1059. }
  1060. private string FormatHostKeyAlgorithmDescription() {
  1061. StringBuilder b = new StringBuilder();
  1062. if(_param.PreferableHostKeyAlgorithms.Length==0) throw new SSHException("HostKeyAlgorithm is not set");
  1063. b.Append(SSH2Util.PublicKeyAlgorithmName(_param.PreferableHostKeyAlgorithms[0]));
  1064. for(int i=1; i<_param.PreferableHostKeyAlgorithms.Length; i++) {
  1065. b.Append(',');
  1066. b.Append(SSH2Util.PublicKeyAlgorithmName(_param.PreferableHostKeyAlgorithms[i]));
  1067. }
  1068. return b.ToString();
  1069. }
  1070. private string FormatCipherAlgorithmDescription() {
  1071. StringBuilder b = new StringBuilder();
  1072. if(_param.PreferableCipherAlgorithms.Length==0) throw new SSHException("CipherAlgorithm is not set");
  1073. b.Append(CipherFactory.AlgorithmToSSH2Name(_param.PreferableCipherAlgorithms[0]));
  1074. for(int i=1; i<_param.PreferableCipherAlgorithms.Length; i++) {
  1075. b.Append(',');
  1076. b.Append(CipherFactory.AlgorithmToSSH2Name(_param.PreferableCipherAlgorithms[i]));
  1077. }
  1078. return b.ToString();
  1079. }
  1081. /*
  1082.  * the seed of diffie-hellman KX defined in the spec of SSH2
  1083.  */ 
  1084. private static BigInteger _dh_prime = null;
  1085. private static BigInteger DH_PRIME {
  1086. get {
  1087. if(_dh_prime==null) {
  1088. StringBuilder sb = new StringBuilder();
  1089. sb.Append("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1");
  1090. sb.Append("29024E088A67CC74020BBEA63B139B22514A08798E3404DD");
  1091. sb.Append("EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245");
  1092. sb.Append("E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED");
  1093. sb.Append("EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381");
  1094. sb.Append("FFFFFFFFFFFFFFFF");
  1095. _dh_prime = new BigInteger(sb.ToString(), 16);
  1096. }
  1097. return _dh_prime;
  1098. }
  1099. }
  1101. }
  1103. }