public void Connect ()
		{
			switch (this.ConnectionType)
			{
				case ConnectionTypes.Telnet:
				{
					this.ConnectTelnet(this.Hostname);
					break;
				}
				case ConnectionTypes.SSH1:
				{
					break;
				}
				case ConnectionTypes.SSH2:
				{
					this.ConnectSSH2(this.Hostname, this.Username, this.Password);
					break;
				}
				default:
				{
					break;
				}
			}
		}
////...

private void ConnectSSH2(string hostname, string username, string password)
		{
			// connect ssh
			this.Focus();
			Routrek.SSHC.SSHConnection _conn;
			Routrek.SSHC.SSHConnectionParameter f = new Routrek.SSHC.SSHConnectionParameter();
			f.UserName = username;
			f.Password = password;
			f.Protocol = Routrek.SSHC.SSHProtocol.SSH2;
			
			f.AuthenticationType = Routrek.SSHC.AuthenticationType.Password;
			f.WindowSize = 0x1000;
			this.reader = new Reader(this);
			Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			//s.Blocking = false;
			IPAddress ip;
			try
			{
				ip = Dns.GetHostByName(hostname).AddressList[0];
			}
			catch
			{
				MessageBox.Show("Unable to resolve HostName");
				return;
			}

			//s.Connect(new IPEndPoint(IPAddress.Parse("0.0.0.0"), 22));
			s.Connect(new IPEndPoint(ip, 22));
			_conn = Routrek.SSHC.SSHConnection.Connect(f, reader, s);
			reader._conn = _conn;
			Routrek.SSHC.SSHChannel ch = _conn.OpenShell(reader);
			reader._pf = ch;
			Routrek.SSHC.SSHConnectionInfo ci = _conn.ConnectionInfo;
		}

sudo sshd -T | grep kex

public static Cipher CreateCipher(SSHProtocol protocol, CipherAlgorithm algorithm, byte[] key) {
			if(protocol==SSHProtocol.SSH1) {
				switch(algorithm) {
					case CipherAlgorithm.TripleDES:
						return new TripleDESCipher1(key);
					case CipherAlgorithm.Blowfish:
						return new BlowfishCipher1(key);
					default:
						throw new SSHException("unknown algorithm " + algorithm);
				}
			}
			else {
				switch(algorithm) {
					case CipherAlgorithm.TripleDES:
						return new TripleDESCipher2(key);
					case CipherAlgorithm.Blowfish:
						return new BlowfishCipher2(key);
					default:
						throw new SSHException("unknown algorithm " + algorithm);
				}
			}
		}

private void ProcessKEXINIT(SSH2Packet packet) {
			_serverKEXINITPayload = packet.Data;
			SSH2DataReader re = new SSH2DataReader(_serverKEXINITPayload);
			byte[] head = re.Read(17); //Type and cookie
			if(head[0]!=(byte)PacketType.SSH_MSG_KEXINIT) throw new SSHException(String.Format("Server response is not SSH_MSG_KEXINIT but {0}", head[0]));
			Encoding enc = Encoding.ASCII;
			
			string kex = enc.GetString(re.ReadString());
			_cInfo._supportedKEXAlgorithms = kex;
			CheckAlgorithmSupport("keyexchange", kex, "diffie-hellman-group1-sha1");
			
			string host_key = enc.GetString(re.ReadString());
			_cInfo._supportedHostKeyAlgorithms = host_key;
			_cInfo._algorithmForHostKeyVerification = DecideHostKeyAlgorithm(host_key);
			
			string enc_cs = enc.GetString(re.ReadString());
			_cInfo._supportedCipherAlgorithms = enc_cs;
			_cInfo._algorithmForTransmittion = DecideCipherAlgorithm(enc_cs);
			
			string enc_sc = enc.GetString(re.ReadString());
			_cInfo._algorithmForReception = DecideCipherAlgorithm(enc_sc);

			string mac_cs = enc.GetString(re.ReadString());
			CheckAlgorithmSupport("mac", mac_cs, "hmac-sha1");
			
			string mac_sc = enc.GetString(re.ReadString());
			CheckAlgorithmSupport("mac", mac_sc, "hmac-sha1");
			
			string comp_cs = enc.GetString(re.ReadString());
			CheckAlgorithmSupport("compression", comp_cs, "none");
			string comp_sc = enc.GetString(re.ReadString());
			CheckAlgorithmSupport("compression", comp_sc, "none");
			
			string lang_cs = enc.GetString(re.ReadString());
			string lang_sc = enc.GetString(re.ReadString());
			bool flag = re.ReadBool();
			int reserved = re.ReadInt32();
			Debug.Assert(re.Rest==0);
			if(flag) throw new SSHException("Algorithm negotiation failed"); 
		}

private void SendKEXINIT() {
			SSH2DataWriter wr = new SSH2DataWriter();
			wr.WritePacketType(PacketType.SSH_MSG_KEXINIT);
			byte[] cookie = new byte[16];
			_param.Random.NextBytes(cookie);
			wr.Write(cookie);
			wr.Write("diffie-hellman-group1-sha1"); //    kex_algorithms
			wr.Write(FormatHostKeyAlgorithmDescription());            //    server_host_key_algorithms
			wr.Write(FormatCipherAlgorithmDescription());      //    encryption_algorithms_client_to_server
			wr.Write(FormatCipherAlgorithmDescription());      //    encryption_algorithms_server_to_client
			wr.Write("hmac-sha1");                  //    mac_algorithms_client_to_server
			wr.Write("hmac-sha1");                  //    mac_algorithms_server_to_client
			wr.Write("none");                       //    compression_algorithms_client_to_server
			wr.Write("none");                       //    compression_algorithms_server_to_client
			wr.Write("");                           //    languages_client_to_server
			wr.Write("");                           //    languages_server_to_client
			wr.Write(false); //Indicates whether a guessed key exchange packet follows
			wr.Write(0);       //reserved for future extension

			_clientKEXINITPayload = wr.ToByteArray();
			_status = Status.WAIT_KEXINIT;
			TransmitPacket(_clientKEXINITPayload);
		}