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

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

Telnet服务器

开发平台：

C#

SSH1Connection.cs：源码内容
  1. /* ---------------------------------------------------------------------------
  2.  *
  3.  * Copyright (c) Granados Networks, Inc.    All Rights Reserved..
  4.  * 
  5.  * This file is a part of the Granados SSH Client Library that is subject to
  6.  * the license included in the distributed package.
  7.  * You may not use this file except in compliance with the license.
  8.  * 
  9.  * ---------------------------------------------------------------------------
  10.  */
  11. using System;
  12. using System.IO;
  13. using System.Security.Cryptography;
  14. using System.Net.Sockets;
  15. using System.Text;
  16. using System.Diagnostics;
  18. using Granados.PKI;
  19. using Granados.SSHC;
  20. using Granados.Toolkit;
  22. namespace Granados.SSHCV1
  23. {
  24. public sealed class SSH1Connection : SSHConnection {
  26. private const int AUTH_NOT_REQUIRED = 0;
  27. private const int AUTH_REQUIRED = 1;
  29. private SSH1ConnectionInfo _cInfo;
  30. private int _shellID;
  32. private SSH1PacketBuilder _packetBuilder;
  33. private bool _executingShell;
  36. public SSH1Connection(SSHConnectionParameter param, ISSHConnectionEventReceiver er, string serverversion, string clientversion) : base(param, er) {
  37. _cInfo = new SSH1ConnectionInfo();
  38. _cInfo._serverVersionString = serverversion;
  39. _cInfo._clientVersionString = clientversion;
  40. _shellID = -1;
  41. _packetBuilder = new SSH1PacketBuilder(new SynchronizedSSH1PacketHandler());
  42. }
  43. public override SSHConnectionInfo ConnectionInfo {
  44. get {
  45. return _cInfo;
  46. }
  47. }
  48. internal override IByteArrayHandler PacketBuilder {
  49. get {
  50. return _packetBuilder;
  51. }
  52. }
  53. public override int ChannelCount {
  54. get {
  55. return base.ChannelCount + 1; //'1' is for the shell
  56. }
  57. }
  59. internal override AuthenticationResult Connect(AbstractSocket s) {
  60. _stream = s;
  62. // Phase2 receives server keys
  63. ReceiveServerKeys();
  64. if(_param.KeyCheck!=null && !_param.KeyCheck(_cInfo)) {
  65. _stream.Close();
  66. return AuthenticationResult.Failure;
  67. }
  69. // Phase3 generates session key
  70. byte[] session_key = GenerateSessionKey();
  72. // Phase4 establishes the session key
  73. try {
  74. _packetBuilder.SetSignal(false);
  75. SendSessionKey(session_key);
  76. InitCipher(session_key);
  77. }
  78. finally {
  79. _packetBuilder.SetSignal(true);
  80. }
  81. ReceiveKeyConfirmation();
  83. // Phase5 user authentication
  84. SendUserName(_param.UserName);
  85. if(ReceiveAuthenticationRequirement()==AUTH_REQUIRED) {
  86. if(_param.AuthenticationType==AuthenticationType.Password) {
  87. SendPlainPassword();
  88. } else if(_param.AuthenticationType==AuthenticationType.PublicKey) {
  89. DoRSAChallengeResponse();
  90. }
  91. bool auth = ReceiveAuthenticationResult();
  92. if(!auth) throw new SSHException(Strings.GetString("AuthenticationFailed"));
  94. }
  96. _packetBuilder.Handler = new CallbackSSH1PacketHandler(this);
  97. return AuthenticationResult.Success;
  98. }
  100. internal void Transmit(SSH1Packet p) {
  101. lock(this) {
  102. p.WriteTo(_stream, _tCipher);
  103. }
  104. }
  106. public override void Disconnect(string msg) {
  107. if(_closed) return;
  108. SSH1DataWriter w = new SSH1DataWriter();
  109. w.Write(msg);
  110. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_DISCONNECT, w.ToByteArray());
  111. p.WriteTo(_stream, _tCipher);
  112. _stream.Flush();
  113. _closed = true;
  114. _stream.Close();
  115. }
  117. public override void Close() {
  118. if(_closed) return;
  119. _closed = true;
  120. _stream.Close();
  121. } 
  123. public override void SendIgnorableData(string msg) {
  124. SSH1DataWriter w = new SSH1DataWriter();
  125. w.Write(msg);
  126. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_IGNORE, w.ToByteArray());
  127. Transmit(p);
  128. }
  131. private void ReceiveServerKeys() {
  132. SSH1Packet SSH1Packet = ReceivePacket();
  133. if(SSH1Packet.Type!=PacketType.SSH_SMSG_PUBLIC_KEY) throw new SSHException("unexpected SSH SSH1Packet type " + SSH1Packet.Type, SSH1Packet.Data);
  135. SSH1DataReader reader = new SSH1DataReader(SSH1Packet.Data);
  136. _cInfo._serverinfo = new SSHServerInfo(reader); 
  137. _cInfo._hostkey = new RSAPublicKey(_cInfo._serverinfo.host_key_public_exponent, _cInfo._serverinfo.host_key_public_modulus);
  139. //read protocol support parameters
  140. int protocol_flags = reader.ReadInt32();
  141. int supported_ciphers_mask = reader.ReadInt32();
  142. _cInfo.SetSupportedCipherAlgorithms(supported_ciphers_mask);
  143. int supported_authentications_mask = reader.ReadInt32();
  144. //Debug.WriteLine(String.Format("ServerOptions {0} {1} {2}", protocol_flags, supported_ciphers_mask, supported_authentications_mask));
  146. if(reader.Rest>0) throw new SSHException("data length mismatch", SSH1Packet.Data);
  148. //Debug Info
  149. /*
  150. System.out.println("Flags="+protocol_flags);
  151. System.out.println("Cipher="+supported_ciphers_mask);
  152. System.out.println("Auth="+supported_authentications_mask);
  153. */
  155. bool found = false;
  156. foreach(CipherAlgorithm a in _param.PreferableCipherAlgorithms) {
  157. if(a!=CipherAlgorithm.Blowfish && a!=CipherAlgorithm.TripleDES)
  158. continue;
  159. else if(a==CipherAlgorithm.Blowfish && (supported_ciphers_mask & (1 << (int)CipherAlgorithm.Blowfish))==0)
  160. continue; 
  161. else if(a==CipherAlgorithm.TripleDES && (supported_ciphers_mask & (1 << (int)CipherAlgorithm.TripleDES))==0)
  162. continue; 
  164. _cInfo._algorithmForReception = _cInfo._algorithmForTransmittion = a;  
  165. found = true;
  166. break;
  167. }
  169. if(!found) 
  170. throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedX"), "Blowfish/TripleDES"));
  172. if(_param.AuthenticationType==AuthenticationType.Password && (supported_authentications_mask & (1 << (int)AuthenticationType.Password))==0)
  173. throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedPassword")), SSH1Packet.Data);
  174. if(_param.AuthenticationType==AuthenticationType.PublicKey && (supported_authentications_mask & (1 << (int)AuthenticationType.PublicKey))==0)
  175. throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedRSA")), SSH1Packet.Data);
  176. }
  178. private byte[] GenerateSessionKey() {
  179. //session key(256bits)
  180. byte[] session_key = new byte[32];
  181. _param.Random.NextBytes(session_key); 
  182. //for(int i=0; i<32; i++) Debug.Write(String.Format("0x{0:x}, ", session_key[i]));
  184. return session_key;
  185. }
  187. private void SendSessionKey(byte[] session_key) {
  188. try
  189. {
  190. //step1 XOR with session_id
  191. byte[] working_data = new byte[session_key.Length];
  192. byte[] session_id = CalcSessionID();
  193. Array.Copy(session_key, 0, working_data, 0, session_key.Length);
  194. for(int i=0; i<session_id.Length; i++) working_data[i] ^= session_id[i];
  196. //step2 decrypts with RSA
  197. RSAPublicKey first_encryption;
  198. RSAPublicKey second_encryption;
  199. SSHServerInfo si = _cInfo._serverinfo;
  200. int first_key_bytelen, second_key_bytelen;
  201. if(si.server_key_bits < si.host_key_bits)
  202. {
  203. first_encryption  = new RSAPublicKey(si.server_key_public_exponent, si.server_key_public_modulus);
  204. second_encryption = new RSAPublicKey(si.host_key_public_exponent, si.host_key_public_modulus);
  205. first_key_bytelen = (si.server_key_bits+7)/8;
  206. second_key_bytelen = (si.host_key_bits+7)/8;
  207. }
  208. else
  209. {
  210. first_encryption  = new RSAPublicKey(si.host_key_public_exponent, si.host_key_public_modulus);
  211. second_encryption = new RSAPublicKey(si.server_key_public_exponent, si.server_key_public_modulus);
  212. first_key_bytelen = (si.host_key_bits+7)/8;
  213. second_key_bytelen = (si.server_key_bits+7)/8;
  214. }
  216. BigInteger first_result = RSAUtil.PKCS1PadType2(new BigInteger(working_data), first_key_bytelen, _param.Random).modPow(first_encryption.Exponent, first_encryption.Modulus);
  217. BigInteger second_result = RSAUtil.PKCS1PadType2(first_result, second_key_bytelen, _param.Random).modPow(second_encryption.Exponent, second_encryption.Modulus);
  219. //output
  220. SSH1DataWriter writer = new SSH1DataWriter();
  221. writer.Write((byte)_cInfo._algorithmForTransmittion);
  222. writer.Write(si.anti_spoofing_cookie);
  223. writer.Write(second_result);
  224. writer.Write(0); //protocol flags
  226. //send
  227. SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_SESSION_KEY, writer.ToByteArray());
  228. SSH1Packet.WriteTo(_stream);
  230. _sessionID = session_id;
  232. }
  233. catch(Exception e)
  234. {
  235. if(e is IOException)
  236. throw (IOException)e;
  237. else
  238. {
  239. string t = e.StackTrace;
  240. throw new SSHException(e.Message); //IOException埲奜偼傒側SSHException偵偟偰偟傑偆
  241. }
  242. }
  243. }
  245. private void ReceiveKeyConfirmation() {
  246. SSH1Packet SSH1Packet = ReceivePacket();
  247. if(SSH1Packet.Type!=PacketType.SSH_SMSG_SUCCESS)
  248. throw new SSHException("unexpected packet type [" + SSH1Packet.Type +"] at ReceiveKeyConfirmation()", SSH1Packet.Data);
  249. }
  251. private int ReceiveAuthenticationRequirement() {
  252. SSH1Packet SSH1Packet = ReceivePacket();
  253. if(SSH1Packet.Type==PacketType.SSH_SMSG_SUCCESS)
  254. return AUTH_NOT_REQUIRED;
  255. else if(SSH1Packet.Type==PacketType.SSH_SMSG_FAILURE)
  256. return AUTH_REQUIRED;  
  257. else
  258. throw new SSHException("type " + SSH1Packet.Type, SSH1Packet.Data);
  259. }
  261. private void SendUserName(string username) {
  262. SSH1DataWriter writer = new SSH1DataWriter();
  263. writer.Write(username);
  264. SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_USER, writer.ToByteArray());
  265. SSH1Packet.WriteTo(_stream, _tCipher);
  266. }
  267. private void SendPlainPassword() {
  268. SSH1DataWriter writer = new SSH1DataWriter();
  269. writer.Write(_param.Password);
  270. SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_AUTH_PASSWORD, writer.ToByteArray());
  271. SSH1Packet.WriteTo(_stream, _tCipher);
  272. }
  274. //RSA authentication
  275. private void DoRSAChallengeResponse() {
  276. //read key
  277. SSH1UserAuthKey key = new SSH1UserAuthKey(_param.IdentityFile, _param.Password);
  278. SSH1DataWriter w = new SSH1DataWriter();
  279. w.Write(key.PublicModulus);
  280. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_AUTH_RSA, w.ToByteArray());
  281. p.WriteTo(_stream, _tCipher);
  283. p = ReceivePacket();
  284. if(p.Type==PacketType.SSH_SMSG_FAILURE)
  285. throw new SSHException(Strings.GetString("ServerRefusedRSA"));
  286. else if(p.Type!=PacketType.SSH_SMSG_AUTH_RSA_CHALLENGE)
  287. throw new SSHException(String.Format(Strings.GetString("UnexpectedResponse"), p.Type));
  289. //creating challenge
  290. SSH1DataReader r = new SSH1DataReader(p.Data);
  291. BigInteger challenge = key.decryptChallenge(r.ReadMPInt());
  292. byte[] rawchallenge = RSAUtil.StripPKCS1Pad(challenge, 2).getBytes();
  294. //building response
  295. MemoryStream bos = new MemoryStream();
  296. bos.Write(rawchallenge, 0, rawchallenge.Length); //!!mindterm偱偼摢偑侽偐偳偆偐偱曄側僴儞僪儕儞僌偑偁偭偨
  297. bos.Write(_sessionID, 0, _sessionID.Length);
  298. byte[] response = new MD5CryptoServiceProvider().ComputeHash(bos.ToArray());
  300. w = new SSH1DataWriter();
  301. w.Write(response);
  302. p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_AUTH_RSA_RESPONSE, w.ToByteArray());
  303. p.WriteTo(_stream, _tCipher);
  305. }
  307. private bool ReceiveAuthenticationResult() {
  308. SSH1Packet SSH1Packet = ReceivePacket();
  309. PacketType type = SSH1Packet.Type;
  310. if(type==PacketType.SSH_MSG_DEBUG) {
  311. SSH1DataReader r = new SSH1DataReader(SSH1Packet.Data);
  312. //Debug.WriteLine("receivedd debug message:"+Encoding.ASCII.GetString(r.ReadString()));
  313. return ReceiveAuthenticationResult();
  314. }
  315. else if(type==PacketType.SSH_SMSG_SUCCESS)
  316. return true;
  317. else if(type==PacketType.SSH_SMSG_FAILURE)
  318. return false;
  319. else
  320. throw new SSHException("type: " + type, SSH1Packet.Data);
  321. }
  323. public override SSHChannel OpenShell(ISSHChannelEventReceiver receiver) {
  324. if(_shellID!=-1)
  325. throw new SSHException("A shell is opened already");
  326. _shellID = RegisterChannelEventReceiver(null, receiver)._localID;
  327. SendRequestPTY();
  328. _executingShell = true;
  329. return new SSH1Channel(this, ChannelType.Shell, _shellID);
  330. }
  332. private void SendRequestPTY() {
  333. SSH1DataWriter writer = new SSH1DataWriter();
  334. writer.Write(_param.TerminalName);
  335. writer.Write(_param.TerminalHeight);
  336. writer.Write(_param.TerminalWidth);
  337. writer.Write(_param.TerminalPixelWidth);
  338. writer.Write(_param.TerminalPixelHeight);
  339. writer.Write(new byte[1]); //TTY_OP_END
  340. SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_REQUEST_PTY, writer.ToByteArray());
  341. SSH1Packet.WriteTo(_stream, _tCipher);
  342. }
  344. private void ExecShell() {
  345. //System.out.println("EXEC SHELL");
  346. SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_EXEC_SHELL);
  347. SSH1Packet.WriteTo(_stream, _tCipher);
  348. }
  350. public override SSHChannel ForwardPort(ISSHChannelEventReceiver receiver, string remote_host, int remote_port, string originator_host, int originator_port) {
  351. if(_shellID==-1) {
  352. ExecShell();
  353. _shellID = RegisterChannelEventReceiver(null, new SSH1DummyReceiver())._localID;
  354. }
  355.  
  356. int local_id = this.RegisterChannelEventReceiver(null, receiver)._localID;
  358. SSH1DataWriter writer = new SSH1DataWriter();
  359. writer.Write(local_id); //channel id is fixed to 0
  360. writer.Write(remote_host);
  361. writer.Write(remote_port);
  362. //originator is specified only if SSH_PROTOFLAG_HOST_IN_FWD_OPEN is specified
  363. //writer.Write(originator_host);
  364. SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_PORT_OPEN, writer.ToByteArray());
  365. SSH1Packet.WriteTo(_stream, _tCipher);
  367. return new SSH1Channel(this, ChannelType.ForwardedLocalToRemote, local_id);
  368. }
  370. public override void ListenForwardedPort(string allowed_host, int bind_port) {
  371. SSH1DataWriter writer = new SSH1DataWriter();
  372. writer.Write(bind_port);
  373. writer.Write(allowed_host);
  374. writer.Write(0);
  375. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_PORT_FORWARD_REQUEST, writer.ToByteArray());
  376. p.WriteTo(_stream, _tCipher);
  378. if(_shellID==-1) {
  379. ExecShell();
  380. _shellID = RegisterChannelEventReceiver(null, new SSH1DummyReceiver())._localID;
  381. }
  383. }
  384. public override void CancelForwardedPort(string host, int port) {
  385. throw new NotSupportedException("not implemented");
  386. }
  388. private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH1Packet packet) {
  389. SSH1DataReader reader = new SSH1DataReader(packet.Data);
  390. int server_channel = reader.ReadInt32();
  391. string host = Encoding.ASCII.GetString(reader.ReadString());
  392. int port = reader.ReadInt32();
  394. SSH1DataWriter writer = new SSH1DataWriter();
  395. PortForwardingCheckResult result = receiver.CheckPortForwardingRequest(host, port, "", 0);
  396. if(result.allowed) {
  397. int local_id = this.RegisterChannelEventReceiver(null, result.channel)._localID;
  398. _eventReceiver.EstablishPortforwarding(result.channel, new SSH1Channel(this, ChannelType.ForwardedRemoteToLocal, local_id, server_channel));
  400. writer.Write(server_channel);
  401. writer.Write(local_id);
  402. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION, writer.ToByteArray());
  403. p.WriteTo(_stream, _tCipher);
  404. }
  405. else {
  406. writer.Write(server_channel);
  407. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE, writer.ToByteArray());
  408. p.WriteTo(_stream, _tCipher);
  409. }
  410. }
  412. private byte[] CalcSessionID() {
  413. MemoryStream bos = new MemoryStream();
  414. SSHServerInfo si = _cInfo._serverinfo;
  415. byte[] h = si.host_key_public_modulus.getBytes(); 
  416. byte[] s = si.server_key_public_modulus.getBytes();
  417. //System.out.println("len h="+h.Length);
  418. //System.out.println("len s="+s.Length);
  420. int off_h = (h[0]==0? 1 : 0);
  421. int off_s = (s[0]==0? 1 : 0);
  422. bos.Write(h, off_h, h.Length-off_h);
  423. bos.Write(s, off_s, s.Length-off_s);
  424. bos.Write(si.anti_spoofing_cookie, 0, si.anti_spoofing_cookie.Length);
  426. byte[] session_id = new MD5CryptoServiceProvider().ComputeHash(bos.ToArray());
  427. //System.out.println("sess-id-len=" + session_id.Length);
  428. return session_id;
  429. }
  431. //init ciphers
  432. private void InitCipher(byte[] session_key) {
  433. _tCipher = CipherFactory.CreateCipher(SSHProtocol.SSH1, _cInfo._algorithmForTransmittion, session_key);
  434. Cipher rc = CipherFactory.CreateCipher(SSHProtocol.SSH1, _cInfo._algorithmForReception, session_key);
  435. _packetBuilder.SetCipher(rc, _param.CheckMACError);
  436. }
  438. private SSH1Packet ReceivePacket() {
  439. while(true) {
  440. SSH1Packet p = null;
  441. SynchronizedSSH1PacketHandler handler = (SynchronizedSSH1PacketHandler)_packetBuilder.Handler;
  442. if(!handler.HasPacket) {
  443. handler.Wait();
  444. if(handler.State==ReceiverState.Error)
  445. throw new SSHException(handler.ErrorMessage);
  446. else if(handler.State==ReceiverState.Closed)
  447. throw new SSHException("socket closed");
  448. }
  449. p = handler.PopPacket();
  451. SSH1DataReader r = new SSH1DataReader(p.Data);
  452. PacketType pt = p.Type;
  453. if(pt==PacketType.SSH_MSG_IGNORE) {
  454. if(_eventReceiver!=null) _eventReceiver.OnIgnoreMessage(r.ReadString());
  455. }
  456. else if(pt==PacketType.SSH_MSG_DEBUG) {
  457. if(_eventReceiver!=null) _eventReceiver.OnDebugMessage(false, r.ReadString());
  458. }
  459. else
  460. return p;
  461. }
  462. }
  464. internal void AsyncReceivePacket(SSH1Packet p) {
  465. try {
  466. int len = 0, channel = 0;
  467. switch(p.Type) {
  468. case PacketType.SSH_SMSG_STDOUT_DATA:
  469. len = SSHUtil.ReadInt32(p.Data, 0);
  470. FindChannelEntry(_shellID)._receiver.OnData(p.Data, 4, len);
  471. break;
  472. case PacketType.SSH_SMSG_STDERR_DATA: {
  473. SSH1DataReader re = new SSH1DataReader(p.Data);
  474. FindChannelEntry(_shellID)._receiver.OnExtendedData((int)PacketType.SSH_SMSG_STDERR_DATA, re.ReadString());
  475. }
  476. break;
  477. case PacketType.SSH_MSG_CHANNEL_DATA:
  478. channel = SSHUtil.ReadInt32(p.Data, 0);
  479. len = SSHUtil.ReadInt32(p.Data, 4);
  480. FindChannelEntry(channel)._receiver.OnData(p.Data, 8, len);
  481. break;
  482. case PacketType.SSH_MSG_PORT_OPEN:
  483. this.ProcessPortforwardingRequest(_eventReceiver, p);
  484. break;
  485. case PacketType.SSH_MSG_CHANNEL_CLOSE: {
  486. channel = SSHUtil.ReadInt32(p.Data, 0);
  487. ISSHChannelEventReceiver r = FindChannelEntry(channel)._receiver;
  488. UnregisterChannelEventReceiver(channel);
  489. r.OnChannelClosed();
  490. }
  491. break;
  492. case PacketType.SSH_MSG_CHANNEL_CLOSE_CONFIRMATION:
  493. channel = SSHUtil.ReadInt32(p.Data, 0);
  494. break;
  495. case PacketType.SSH_MSG_DISCONNECT:
  496. _eventReceiver.OnConnectionClosed();
  497. break;
  498. case PacketType.SSH_SMSG_EXITSTATUS:
  499. FindChannelEntry(_shellID)._receiver.OnChannelClosed();
  500. break;
  501. case PacketType.SSH_MSG_DEBUG: {
  502. SSH1DataReader re = new SSH1DataReader(p.Data);
  503. _eventReceiver.OnDebugMessage(false, re.ReadString());
  504. }
  505. break;
  506. case PacketType.SSH_MSG_IGNORE: {
  507. SSH1DataReader re = new SSH1DataReader(p.Data);
  508. _eventReceiver.OnIgnoreMessage(re.ReadString());
  509. }
  510. break;
  511. case PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION: {
  512. int local = SSHUtil.ReadInt32(p.Data, 0);
  513. int remote = SSHUtil.ReadInt32(p.Data, 4);
  514. FindChannelEntry(local)._receiver.OnChannelReady();
  515. }
  516. break;
  517. case PacketType.SSH_SMSG_SUCCESS:
  518. if(_executingShell) {
  519. ExecShell();
  520. this.FindChannelEntry(_shellID)._receiver.OnChannelReady();
  521. _executingShell = false;
  522. }
  523. break;
  524. default:
  525. _eventReceiver.OnUnknownMessage((byte)p.Type, p.Data);
  526. break;
  527. }
  528. }
  529. catch(Exception ex) {
  530. if(!_closed)
  531. _eventReceiver.OnError(ex, ex.Message);
  532. }
  533. }
  535. }
  537. public class SSH1Channel : SSHChannel {
  539. public SSH1Channel(SSHConnection con, ChannelType type, int local_id) : base(con, type, local_id) {
  540. }
  541. public SSH1Channel(SSHConnection con, ChannelType type, int local_id, int remote_id) : base(con, type, local_id) {
  542. _remoteID = remote_id;
  543. }
  545. /**
  546.  * resizes the size of terminal
  547.  */
  548. public override void ResizeTerminal(int width, int height, int pixel_width, int pixel_height) {
  549. SSH1DataWriter writer = new SSH1DataWriter();
  550. writer.Write(height);
  551. writer.Write(width);
  552. writer.Write(pixel_width);
  553. writer.Write(pixel_height);
  554. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_WINDOW_SIZE, writer.ToByteArray());
  555. Transmit(p);
  556. }
  558. /**
  559. * transmits channel data 
  560. */
  561. public override void Transmit(byte[] data) {
  562. SSH1DataWriter wr = new SSH1DataWriter();
  563. if(_type==ChannelType.Shell) {
  564. wr.WriteAsString(data);
  565. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_STDIN_DATA, wr.ToByteArray());
  566. Transmit(p);
  567. }
  568. else {
  569. wr.Write(_remoteID);
  570. wr.WriteAsString(data);
  571. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_DATA, wr.ToByteArray());
  572. Transmit(p);
  573. }
  574. }
  575. /**
  576. * transmits channel data 
  577. */
  578. public override void Transmit(byte[] data, int offset, int length) {
  579. SSH1DataWriter wr = new SSH1DataWriter();
  580. if(_type==ChannelType.Shell) {
  581. wr.WriteAsString(data, offset, length);
  582. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_STDIN_DATA, wr.ToByteArray());
  583. Transmit(p);
  584. }
  585. else {
  586. wr.Write(_remoteID);
  587. wr.WriteAsString(data, offset, length);
  588. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_DATA, wr.ToByteArray());
  589. Transmit(p);
  590. }
  591. }
  593. public override void SendEOF() {
  594. }
  597. /**
  598.  * closes this channel
  599.  */
  600. public override void Close() {
  601. if(_connection.IsClosed) return;
  603. if(_type==ChannelType.Shell) {
  604. SSH1DataWriter wr2 = new SSH1DataWriter();
  605. wr2.Write(_remoteID);
  606. SSH1Packet p2 = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_EOF, wr2.ToByteArray());
  607. Transmit(p2);
  608. }
  610. SSH1DataWriter wr = new SSH1DataWriter();
  611. wr.Write(_remoteID);
  612. SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_CLOSE, wr.ToByteArray());
  613. Transmit(p);
  614. }
  616. private void Transmit(SSH1Packet p) {
  617. ((SSH1Connection)_connection).Transmit(p);
  618. }
  619. }
  621. //if port forwardings are performed without a shell, we use SSH1DummyChannel to receive shell data
  622. internal class SSH1DummyReceiver : ISSHChannelEventReceiver {
  623. public void OnData(byte[] data, int offset, int length) {
  624. }
  625. public void OnExtendedData(int type, byte[] data) {
  626. }
  627. public void OnChannelClosed() {
  628. }
  629. public void OnChannelEOF() {
  630. }
  631. public void OnChannelReady() {
  632. }
  633. public void OnChannelError(Exception error, string msg) {
  634. }
  635. public void OnMiscPacket(byte packet_type, byte[] data, int offset, int length) {
  636. }
  637. }
  638. }