Exemplo n.º 1
0
        //public IAsyncAction OnData(byte[] data, int offset, int length) {
        public void OnData(byte[] data, int offset, int length)
        {
            //return Task.Run(async () =>
            //{
            try
            {
                while (_buffer.Length - _writeOffset < length)
                {
                    ExpandBuffer();
                }
                Array.Copy(data, offset, _buffer, _writeOffset, length);
                _writeOffset += length;

                SSH1Packet p = ConstructPacket();
                while (p != null)
                {
                    //await _handler.OnPacket(p);
                    _handler.OnPacket(p);
                    p = ConstructPacket();
                }
                ReduceBuffer();
            }
            catch (Exception ex)
            {
                OnError(ex, ex.Message);
            }
            //}).AsAsyncAction();
        }
Exemplo n.º 2
0
        private void ExecShell()
        {
            //System.out.println("EXEC SHELL");
            SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_EXEC_SHELL);

            SSH1Packet.WriteTo(_stream, _tCipher);
        }
Exemplo n.º 3
0
        private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH1Packet packet)
        {
            SSH1DataReader reader         = new SSH1DataReader(packet.Data);
            int            server_channel = reader.ReadInt32();

            byte[] tmpdata = reader.ReadString();
            string host    = Encoding.UTF8.GetString(tmpdata, 0, tmpdata.Length);
            int    port    = reader.ReadInt32();

            SSH1DataWriter            writer = new SSH1DataWriter();
            PortForwardingCheckResult result = receiver.CheckPortForwardingRequest(host, port, "", 0);

            if (result.allowed)
            {
                int local_id = this.RegisterChannelEventReceiver(null, result.channel)._localID;
                _eventReceiver.EstablishPortforwarding(result.channel, new SSH1Channel(this, ChannelType.ForwardedRemoteToLocal, local_id, server_channel));

                writer.Write(server_channel);
                writer.Write(local_id);
                SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION, writer.ToByteArray());
                p.WriteTo(_stream, _tCipher);
            }
            else
            {
                writer.Write(server_channel);
                SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE, writer.ToByteArray());
                p.WriteTo(_stream, _tCipher);
            }
        }
Exemplo n.º 4
0
        public static SSH1Packet FromPlainPayload(PacketType type)
        {
            SSH1Packet p = new SSH1Packet();

            p._type = (byte)type;
            p._data = new byte[0];
            return(p);
        }
Exemplo n.º 5
0
        /**
         * creates a packet as the input of shell
         */
        static SSH1Packet AsStdinString(byte[] input)
        {
            SSH1DataWriter w = new SSH1DataWriter();

            w.WriteAsString(input);
            SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_STDIN_DATA, w.ToByteArray());

            return(p);
        }
Exemplo n.º 6
0
        private void ReceiveKeyConfirmation()
        {
            SSH1Packet SSH1Packet = ReceivePacket();

            if (SSH1Packet.Type != PacketType.SSH_SMSG_SUCCESS)
            {
                throw new Exception("unexpected packet type [" + SSH1Packet.Type + "] at ReceiveKeyConfirmation()");
            }
        }
Exemplo n.º 7
0
        private void SendUserName(string username)
        {
            SSH1DataWriter writer = new SSH1DataWriter();

            writer.Write(username);
            SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_USER, writer.ToByteArray());

            SSH1Packet.WriteTo(_stream, _tCipher);
        }
Exemplo n.º 8
0
        private void SendPlainPassword()
        {
            SSH1DataWriter writer = new SSH1DataWriter();

            writer.Write(_param.Password);
            SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_AUTH_PASSWORD, writer.ToByteArray());

            SSH1Packet.WriteTo(_stream, _tCipher);
        }
Exemplo n.º 9
0
        public void SendIgnorableData(string msg)
        {
            SSH1DataWriter w = new SSH1DataWriter();

            w.Write(msg);
            SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_IGNORE, w.ToByteArray());

            Transmit(p);
        }
Exemplo n.º 10
0
        /**
         * resizes the size of terminal
         */
        public void ResizeTerminal(int width, int height, int pixel_width, int pixel_height)
        {
            SSH1DataWriter writer = new SSH1DataWriter();

            writer.Write(height);
            writer.Write(width);
            writer.Write(pixel_width);
            writer.Write(pixel_height);
            SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_WINDOW_SIZE, writer.ToByteArray());

            Transmit(p);
        }
Exemplo n.º 11
0
 //public Task OnPacket(SSH1Packet packet) {
 public void OnPacket(SSH1Packet packet)
 {
     //return Task.Run(() =>
     //{
     lock (this)
     {
         _packets.Add(packet);
         if (_packets.Count > 0)
         {
             SetReady();
         }
     }
     //});
 }
Exemplo n.º 12
0
        private void SendRequestPTY()
        {
            SSH1DataWriter writer = new SSH1DataWriter();

            writer.Write(_param.TerminalName);
            writer.Write(_param.TerminalHeight);
            writer.Write(_param.TerminalWidth);
            writer.Write(_param.TerminalPixelWidth);
            writer.Write(_param.TerminalPixelHeight);
            writer.Write(new byte[1]);             //TTY_OP_END
            SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_REQUEST_PTY, writer.ToByteArray());

            SSH1Packet.WriteTo(_stream, _tCipher);
        }
Exemplo n.º 13
0
        public void Disconnect(string msg)
        {
            if (_closed)
            {
                return;
            }
            SSH1DataWriter w = new SSH1DataWriter();

            w.Write(msg);
            SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_DISCONNECT, w.ToByteArray());

            p.WriteTo(_stream, _tCipher);
            _stream.Flush();
            _closed = true;
            _stream.Close();
        }
Exemplo n.º 14
0
        private int ReceiveAuthenticationRequirement()
        {
            SSH1Packet SSH1Packet = ReceivePacket();

            if (SSH1Packet.Type == PacketType.SSH_SMSG_SUCCESS)
            {
                return(AUTH_NOT_REQUIRED);
            }
            else if (SSH1Packet.Type == PacketType.SSH_SMSG_FAILURE)
            {
                return(AUTH_REQUIRED);
            }
            else
            {
                throw new Exception("type " + SSH1Packet.Type);
            }
        }
Exemplo n.º 15
0
        public void ListenForwardedPort(string allowed_host, int bind_port)
        {
            SSH1DataWriter writer = new SSH1DataWriter();

            writer.Write(bind_port);
            writer.Write(allowed_host);
            writer.Write(0);
            SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_PORT_FORWARD_REQUEST, writer.ToByteArray());

            p.WriteTo(_stream, _tCipher);

            if (_shellID == -1)
            {
                ExecShell();
                _shellID = RegisterChannelEventReceiver(null, new SSH1DummyReceiver())._localID;
            }
        }
Exemplo n.º 16
0
        /**
         * transmits channel data
         */
        public void Transmit(byte[] data)
        {
            SSH1DataWriter wr = new SSH1DataWriter();

            if (_type == ChannelType.Shell)
            {
                wr.WriteAsString(data);
                SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_STDIN_DATA, wr.ToByteArray());
                Transmit(p);
            }
            else
            {
                wr.Write(_remoteID);
                wr.WriteAsString(data);
                SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_DATA, wr.ToByteArray());
                Transmit(p);
            }
        }
Exemplo n.º 17
0
        private SSH1Packet ReceivePacket()
        {
            while (true)
            {
                SSH1Packet p = null;
                SynchronizedSSH1PacketHandler handler = (SynchronizedSSH1PacketHandler)_packetBuilder.Handler;
                if (!handler.HasPacket)
                {
                    handler.Wait();
                    if (handler.State == ReceiverState.Error)
                    {
                        throw new Exception(handler.ErrorMessage);
                    }
                    else if (handler.State == ReceiverState.Closed)
                    {
                        throw new Exception("socket closed");
                    }
                }
                p = handler.PopPacket();

                SSH1DataReader r  = new SSH1DataReader(p.Data);
                PacketType     pt = p.Type;
                if (pt == PacketType.SSH_MSG_IGNORE)
                {
                    if (_eventReceiver != null)
                    {
                        _eventReceiver.OnIgnoreMessage(r.ReadString());
                    }
                }
                else if (pt == PacketType.SSH_MSG_DEBUG)
                {
                    if (_eventReceiver != null)
                    {
                        _eventReceiver.OnDebugMessage(false, r.ReadString());
                    }
                }
                else
                {
                    return(p);
                }
            }
        }
Exemplo n.º 18
0
 public SSH1Packet PopPacket()
 {
     lock (this) {
         if (_packets.Count == 0)
         {
             return(null);
         }
         else
         {
             SSH1Packet p = null;
             p = (SSH1Packet)_packets[0];
             _packets.RemoveAt(0);
             if (_packets.Count == 0)
             {
                 _event.Reset();
             }
             return(p);
         }
     }
 }
Exemplo n.º 19
0
        /**
         * closes this channel
         */
        public void Close()
        {
            if (_connection.IsClosed())
            {
                return;
            }

            if (_type == ChannelType.Shell)
            {
                SSH1DataWriter wr2 = new SSH1DataWriter();
                wr2.Write(_remoteID);
                SSH1Packet p2 = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_EOF, wr2.ToByteArray());
                Transmit(p2);
            }

            SSH1DataWriter wr = new SSH1DataWriter();

            wr.Write(_remoteID);
            SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_CLOSE, wr.ToByteArray());

            Transmit(p);
        }
Exemplo n.º 20
0
        //RSA authentication
        private void DoRSAChallengeResponse()
        {
            //read key
            SSH1UserAuthKey key = new SSH1UserAuthKey(_param.IdentityFile, _param.Password);
            SSH1DataWriter  w   = new SSH1DataWriter();

            w.Write(key.PublicModulus);
            SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_AUTH_RSA, w.ToByteArray());

            p.WriteTo(_stream, _tCipher);

            p = ReceivePacket();
            if (p.Type == PacketType.SSH_SMSG_FAILURE)
            {
                throw new Exception(Strings.GetString("ServerRefusedRSA"));
            }
            else if (p.Type != PacketType.SSH_SMSG_AUTH_RSA_CHALLENGE)
            {
                throw new Exception(String.Format(Strings.GetString("UnexpectedResponse"), p.Type));
            }

            //creating challenge
            SSH1DataReader r         = new SSH1DataReader(p.Data);
            BigInteger     challenge = key.decryptChallenge(r.ReadMPInt());

            byte[] rawchallenge = RSAUtil.StripPKCS1Pad(challenge, 2).getBytes();

            //building response
            MemoryStream bos = new MemoryStream();

            bos.Write(rawchallenge, 0, rawchallenge.Length);             //!!mindtermでは頭が0かどうかで変なハンドリングがあった
            bos.Write(_sessionID, 0, _sessionID.Length);
            byte[] response = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5).HashData(bos.ToArray().AsBuffer()).ToArray();;

            w = new SSH1DataWriter();
            w.Write(response);
            p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_AUTH_RSA_RESPONSE, w.ToByteArray());
            p.WriteTo(_stream, _tCipher);
        }
Exemplo n.º 21
0
        public SSHChannel ForwardPort(ISSHChannelEventReceiver receiver, string remote_host, int remote_port, string originator_host, int originator_port)
        {
            if (_shellID == -1)
            {
                ExecShell();
                _shellID = RegisterChannelEventReceiver(null, new SSH1DummyReceiver())._localID;
            }

            int local_id = this.RegisterChannelEventReceiver(null, receiver)._localID;

            SSH1DataWriter writer = new SSH1DataWriter();

            writer.Write(local_id);             //channel id is fixed to 0
            writer.Write(remote_host);
            writer.Write(remote_port);
            //originator is specified only if SSH_PROTOFLAG_HOST_IN_FWD_OPEN is specified
            //writer.Write(originator_host);
            SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_PORT_OPEN, writer.ToByteArray());

            SSH1Packet.WriteTo(_stream, _tCipher);

            return(new SSH1Channel(this, ChannelType.ForwardedLocalToRemote, local_id));
        }
Exemplo n.º 22
0
        private bool ReceiveAuthenticationResult()
        {
            SSH1Packet SSH1Packet = ReceivePacket();
            PacketType type       = SSH1Packet.Type;

            if (type == PacketType.SSH_MSG_DEBUG)
            {
                SSH1DataReader r = new SSH1DataReader(SSH1Packet.Data);
                //Debug.WriteLine("receivedd debug message:"+Encoding.ASCII.GetString(r.ReadString()));
                return(ReceiveAuthenticationResult());
            }
            else if (type == PacketType.SSH_SMSG_SUCCESS)
            {
                return(true);
            }
            else if (type == PacketType.SSH_SMSG_FAILURE)
            {
                return(false);
            }
            else
            {
                throw new Exception("type: " + type);
            }
        }
Exemplo n.º 23
0
        //returns true if a new packet could be obtained
        private SSH1Packet ConstructPacket()
        {
            if (_event != null && !_event.WaitOne(3000))
            {
                throw new Exception("waithandle timed out");
            }

            if (_writeOffset - _readOffset < 4)
            {
                return(null);
            }
            int packet_length  = SSHUtil.ReadInt32(_buffer, _readOffset);
            int padding_length = 8 - (packet_length % 8);             //padding length
            int total          = packet_length + padding_length;

            if (_writeOffset - _readOffset < 4 + total)
            {
                return(null);
            }

            byte[] decrypted = new byte[total];
            if (_cipher != null)
            {
                _cipher.Decrypt(_buffer, _readOffset + 4, total, decrypted, 0);
            }
            else
            {
                Array.Copy(_buffer, _readOffset + 4, decrypted, 0, total);
            }
            _readOffset += 4 + total;

            SSH1Packet p = new SSH1Packet();

            p.ConstructAndCheck(decrypted, packet_length, padding_length, _checkMAC);
            return(p);
        }
Exemplo n.º 24
0
 //public async Task OnPacket(SSH1Packet packet) {
 public void OnPacket(SSH1Packet packet)
 {
     //await _connection.AsyncReceivePacket(packet);
     _connection.AsyncReceivePacket(packet);
 }
Exemplo n.º 25
0
 //internal async Task AsyncReceivePacket(SSH1Packet p) {
 internal void AsyncReceivePacket(SSH1Packet p)
 {
     try {
         int len = 0, channel = 0;
         switch(p.Type) {
             case PacketType.SSH_SMSG_STDOUT_DATA:
                 len = SSHUtil.ReadInt32(p.Data, 0);
                 //await FindChannelEntry(_shellID)._receiver.OnData(p.Data, 4, len);
                 FindChannelEntry(_shellID)._receiver.OnData(p.Data, 4, len);
                 break;
             case PacketType.SSH_SMSG_STDERR_DATA: {
                 SSH1DataReader re = new SSH1DataReader(p.Data);
                 FindChannelEntry(_shellID)._receiver.OnExtendedData((int)PacketType.SSH_SMSG_STDERR_DATA, re.ReadString());
             }
                 break;
             case PacketType.SSH_MSG_CHANNEL_DATA:
                 channel = SSHUtil.ReadInt32(p.Data, 0);
                 len = SSHUtil.ReadInt32(p.Data, 4);
                 //await FindChannelEntry(channel)._receiver.OnData(p.Data, 8, len);
                 FindChannelEntry(channel)._receiver.OnData(p.Data, 8, len);
                 break;
             case PacketType.SSH_MSG_PORT_OPEN:
                 this.ProcessPortforwardingRequest(_eventReceiver, p);
                 break;
             case PacketType.SSH_MSG_CHANNEL_CLOSE: {
                 channel = SSHUtil.ReadInt32(p.Data, 0);
                 ISSHChannelEventReceiver r = FindChannelEntry(channel)._receiver;
                 UnregisterChannelEventReceiver(channel);
                 r.OnChannelClosed();
             }
                 break;
             case PacketType.SSH_MSG_CHANNEL_CLOSE_CONFIRMATION:
                 channel = SSHUtil.ReadInt32(p.Data, 0);
                 break;
             case PacketType.SSH_MSG_DISCONNECT:
                 _eventReceiver.OnConnectionClosed();
                 break;
             case PacketType.SSH_SMSG_EXITSTATUS:
                 FindChannelEntry(_shellID)._receiver.OnChannelClosed();
                 break;
             case PacketType.SSH_MSG_DEBUG: {
                 SSH1DataReader re = new SSH1DataReader(p.Data);
                 _eventReceiver.OnDebugMessage(false, re.ReadString());
             }
                 break;
             case PacketType.SSH_MSG_IGNORE: {
                 SSH1DataReader re = new SSH1DataReader(p.Data);
                 _eventReceiver.OnIgnoreMessage(re.ReadString());
             }
                 break;
             case PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION: {
                 int local = SSHUtil.ReadInt32(p.Data, 0);
                 int remote = SSHUtil.ReadInt32(p.Data, 4);
                 FindChannelEntry(local)._receiver.OnChannelReady();
             }
                 break;
             case PacketType.SSH_SMSG_SUCCESS:
                 if(_executingShell) {
                     ExecShell();
                     this.FindChannelEntry(_shellID)._receiver.OnChannelReady();
                     _executingShell = false;
                 }
                 break;
             default:
                 _eventReceiver.OnUnknownMessage((byte)p.Type, p.Data);
                 break;
         }
     }
     catch(Exception ex) {
         if(!_closed)
             _eventReceiver.OnError(ex, ex.Message);
     }
 }
Exemplo n.º 26
0
 internal void Transmit(SSH1Packet p)
 {
     lock(this) {
         p.WriteTo(_stream, _tCipher);
     }
 }
Exemplo n.º 27
0
        private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH1Packet packet)
        {
            SSH1DataReader reader = new SSH1DataReader(packet.Data);
            int server_channel = reader.ReadInt32();
            byte[] tmpdata = reader.ReadString();
            string host = Encoding.UTF8.GetString(tmpdata,0, tmpdata.Length);
            int port = reader.ReadInt32();

            SSH1DataWriter writer = new SSH1DataWriter();
            PortForwardingCheckResult result = receiver.CheckPortForwardingRequest(host, port, "", 0);
            if(result.allowed) {
                int local_id = this.RegisterChannelEventReceiver(null, result.channel)._localID;
                _eventReceiver.EstablishPortforwarding(result.channel, new SSH1Channel(this, ChannelType.ForwardedRemoteToLocal, local_id, server_channel));

                writer.Write(server_channel);
                writer.Write(local_id);
                SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION, writer.ToByteArray());
                p.WriteTo(_stream, _tCipher);
            }
            else {
                writer.Write(server_channel);
                SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE, writer.ToByteArray());
                p.WriteTo(_stream, _tCipher);
            }
        }
Exemplo n.º 28
0
 internal void Transmit(SSH1Packet p)
 {
     lock (this) {
         p.WriteTo(_stream, _tCipher);
     }
 }
Exemplo n.º 29
0
 //public Task OnPacket(SSH1Packet packet) {
 public void OnPacket(SSH1Packet packet)
 {
     //return Task.Run(() =>
     //{
         lock (this)
         {
             _packets.Add(packet);
             if (_packets.Count > 0)
                 SetReady();
         }
     //});
 }
Exemplo n.º 30
0
        //returns true if a new packet could be obtained
        private SSH1Packet ConstructPacket()
        {
            if(_event!=null && !_event.WaitOne(3000))
                throw new Exception("waithandle timed out");

            if(_writeOffset-_readOffset<4) return null;
            int packet_length = SSHUtil.ReadInt32(_buffer, _readOffset);
            int padding_length = 8 - (packet_length % 8); //padding length
            int total = packet_length + padding_length;
            if(_writeOffset-_readOffset<4+total) return null;

            byte[] decrypted = new byte[total];
            if(_cipher!=null)
                _cipher.Decrypt(_buffer, _readOffset+4, total, decrypted, 0);
            else
                Array.Copy(_buffer, _readOffset+4, decrypted, 0, total);
            _readOffset += 4 + total;

            SSH1Packet p = new SSH1Packet();
            p.ConstructAndCheck(decrypted, packet_length, padding_length, _checkMAC);
            return p;
        }
Exemplo n.º 31
0
 //public async Task OnPacket(SSH1Packet packet) {
 public void OnPacket(SSH1Packet packet)
 {
     //await _connection.AsyncReceivePacket(packet);
     _connection.AsyncReceivePacket(packet);
 }
Exemplo n.º 32
0
        private void SendSessionKey(byte[] session_key)
        {
            try
            {
                //step1 XOR with session_id
                byte[] working_data = new byte[session_key.Length];
                byte[] session_id   = CalcSessionID();
                Array.Copy(session_key, 0, working_data, 0, session_key.Length);
                for (int i = 0; i < session_id.Length; i++)
                {
                    working_data[i] ^= session_id[i];
                }

                //step2 decrypts with RSA
                RSAPublicKey  first_encryption;
                RSAPublicKey  second_encryption;
                SSHServerInfo si = _cInfo._serverinfo;
                int           first_key_bytelen, second_key_bytelen;
                if (si.server_key_bits < si.host_key_bits)
                {
                    first_encryption   = new RSAPublicKey(si.server_key_public_exponent, si.server_key_public_modulus);
                    second_encryption  = new RSAPublicKey(si.host_key_public_exponent, si.host_key_public_modulus);
                    first_key_bytelen  = (si.server_key_bits + 7) / 8;
                    second_key_bytelen = (si.host_key_bits + 7) / 8;
                }
                else
                {
                    first_encryption   = new RSAPublicKey(si.host_key_public_exponent, si.host_key_public_modulus);
                    second_encryption  = new RSAPublicKey(si.server_key_public_exponent, si.server_key_public_modulus);
                    first_key_bytelen  = (si.host_key_bits + 7) / 8;
                    second_key_bytelen = (si.server_key_bits + 7) / 8;
                }

                BigInteger first_result  = RSAUtil.PKCS1PadType2(new BigInteger(working_data), first_key_bytelen, _param.Random).modPow(first_encryption.Exponent, first_encryption.Modulus);
                BigInteger second_result = RSAUtil.PKCS1PadType2(first_result, second_key_bytelen, _param.Random).modPow(second_encryption.Exponent, second_encryption.Modulus);

                //output
                SSH1DataWriter writer = new SSH1DataWriter();
                writer.Write((byte)_cInfo._algorithmForTransmittion);
                writer.Write(si.anti_spoofing_cookie);
                writer.Write(second_result);
                writer.Write(0);                 //protocol flags

                //send
                SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_SESSION_KEY, writer.ToByteArray());
                SSH1Packet.WriteTo(_stream);

                _sessionID = session_id;
            }
            catch (Exception e)
            {
                if (e is IOException)
                {
                    throw (IOException)e;
                }
                else
                {
                    string t = e.StackTrace;
                    throw new Exception(e.Message);                     //IOException以外はみなSSHExceptionにしてしまう
                }
            }
        }
Exemplo n.º 33
0
        private void ReceiveServerKeys()
        {
            SSH1Packet SSH1Packet = ReceivePacket();

            if (SSH1Packet.Type != PacketType.SSH_SMSG_PUBLIC_KEY)
            {
                throw new Exception("unexpected SSH SSH1Packet type " + SSH1Packet.Type);
            }

            SSH1DataReader reader = new SSH1DataReader(SSH1Packet.Data);

            _cInfo._serverinfo = new SSHServerInfo(reader);
            _cInfo._hostkey    = new RSAPublicKey(_cInfo._serverinfo.host_key_public_exponent, _cInfo._serverinfo.host_key_public_modulus);

            //read protocol support parameters
            int protocol_flags         = reader.ReadInt32();
            int supported_ciphers_mask = reader.ReadInt32();

            _cInfo.SetSupportedCipherAlgorithms(supported_ciphers_mask);
            int supported_authentications_mask = reader.ReadInt32();

            //Debug.WriteLine(String.Format("ServerOptions {0} {1} {2}", protocol_flags, supported_ciphers_mask, supported_authentications_mask));

            if (reader.Rest > 0)
            {
                throw new Exception("data length mismatch");
            }

            //Debug Info

            /*
             * System.out.println("Flags="+protocol_flags);
             * System.out.println("Cipher="+supported_ciphers_mask);
             * System.out.println("Auth="+supported_authentications_mask);
             */

            bool found = false;

            foreach (CipherAlgorithm a in _param.PreferableCipherAlgorithms)
            {
                if (a != CipherAlgorithm.Blowfish && a != CipherAlgorithm.TripleDES)
                {
                    continue;
                }
                else if (a == CipherAlgorithm.Blowfish && (supported_ciphers_mask & (1 << (int)CipherAlgorithm.Blowfish)) == 0)
                {
                    continue;
                }
                else if (a == CipherAlgorithm.TripleDES && (supported_ciphers_mask & (1 << (int)CipherAlgorithm.TripleDES)) == 0)
                {
                    continue;
                }

                _cInfo._algorithmForReception = _cInfo._algorithmForTransmittion = a;
                found = true;
                break;
            }

            if (!found)
            {
                throw new Exception(String.Format(Strings.GetString("ServerNotSupportedX"), "Blowfish/TripleDES"));
            }

            if (_param.AuthenticationType == AuthenticationType.Password && (supported_authentications_mask & (1 << (int)AuthenticationType.Password)) == 0)
            {
                throw new Exception(String.Format(Strings.GetString("ServerNotSupportedPassword")));
            }
            if (_param.AuthenticationType == AuthenticationType.PublicKey && (supported_authentications_mask & (1 << (int)AuthenticationType.PublicKey)) == 0)
            {
                throw new Exception(String.Format(Strings.GetString("ServerNotSupportedRSA")));
            }
        }
Exemplo n.º 34
0
        //internal async Task AsyncReceivePacket(SSH1Packet p) {
        internal void AsyncReceivePacket(SSH1Packet p)
        {
            try {
                int len = 0, channel = 0;
                switch (p.Type)
                {
                case PacketType.SSH_SMSG_STDOUT_DATA:
                    len = SSHUtil.ReadInt32(p.Data, 0);
                    //await FindChannelEntry(_shellID)._receiver.OnData(p.Data, 4, len);
                    FindChannelEntry(_shellID)._receiver.OnData(p.Data, 4, len);
                    break;

                case PacketType.SSH_SMSG_STDERR_DATA: {
                    SSH1DataReader re = new SSH1DataReader(p.Data);
                    FindChannelEntry(_shellID)._receiver.OnExtendedData((int)PacketType.SSH_SMSG_STDERR_DATA, re.ReadString());
                }
                break;

                case PacketType.SSH_MSG_CHANNEL_DATA:
                    channel = SSHUtil.ReadInt32(p.Data, 0);
                    len     = SSHUtil.ReadInt32(p.Data, 4);
                    //await FindChannelEntry(channel)._receiver.OnData(p.Data, 8, len);
                    FindChannelEntry(channel)._receiver.OnData(p.Data, 8, len);
                    break;

                case PacketType.SSH_MSG_PORT_OPEN:
                    this.ProcessPortforwardingRequest(_eventReceiver, p);
                    break;

                case PacketType.SSH_MSG_CHANNEL_CLOSE: {
                    channel = SSHUtil.ReadInt32(p.Data, 0);
                    ISSHChannelEventReceiver r = FindChannelEntry(channel)._receiver;
                    UnregisterChannelEventReceiver(channel);
                    r.OnChannelClosed();
                }
                break;

                case PacketType.SSH_MSG_CHANNEL_CLOSE_CONFIRMATION:
                    channel = SSHUtil.ReadInt32(p.Data, 0);
                    break;

                case PacketType.SSH_MSG_DISCONNECT:
                    _eventReceiver.OnConnectionClosed();
                    break;

                case PacketType.SSH_SMSG_EXITSTATUS:
                    FindChannelEntry(_shellID)._receiver.OnChannelClosed();
                    break;

                case PacketType.SSH_MSG_DEBUG: {
                    SSH1DataReader re = new SSH1DataReader(p.Data);
                    _eventReceiver.OnDebugMessage(false, re.ReadString());
                }
                break;

                case PacketType.SSH_MSG_IGNORE: {
                    SSH1DataReader re = new SSH1DataReader(p.Data);
                    _eventReceiver.OnIgnoreMessage(re.ReadString());
                }
                break;

                case PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION: {
                    int local  = SSHUtil.ReadInt32(p.Data, 0);
                    int remote = SSHUtil.ReadInt32(p.Data, 4);
                    FindChannelEntry(local)._receiver.OnChannelReady();
                }
                break;

                case PacketType.SSH_SMSG_SUCCESS:
                    if (_executingShell)
                    {
                        ExecShell();
                        this.FindChannelEntry(_shellID)._receiver.OnChannelReady();
                        _executingShell = false;
                    }
                    break;

                default:
                    _eventReceiver.OnUnknownMessage((byte)p.Type, p.Data);
                    break;
                }
            }
            catch (Exception ex) {
                if (!_closed)
                {
                    _eventReceiver.OnError(ex, ex.Message);
                }
            }
        }
Exemplo n.º 35
0
 private void Transmit(SSH1Packet p)
 {
     ((SSH1Connection)_connection).Transmit(p);
 }
Exemplo n.º 36
0
 public static SSH1Packet FromPlainPayload(PacketType type)
 {
     SSH1Packet p = new SSH1Packet();
     p._type = (byte)type;
     p._data = new byte[0];
     return p;
 }
Exemplo n.º 37
0
 private void Transmit(SSH1Packet p)
 {
     ((SSH1Connection)_connection).Transmit(p);
 }