Example #1
0
        /// <summary>
        /// Constructor (initiated by server)
        /// </summary>
        public SSH2ChannelBase(
                IPacketSender<SSH2Packet> packetSender,
                SSHConnectionParameter param,
                SSHProtocolEventManager protocolEventManager,
                uint localChannel,
                uint remoteChannel,
                ChannelType channelType,
                string channelTypeString,
                uint serverWindowSize,
                uint serverMaxPacketSize)
        {
            _packetSender = packetSender;
            _protocolEventManager = protocolEventManager;
            LocalChannel = localChannel;
            RemoteChannel = remoteChannel;
            ChannelType = channelType;
            ChannelTypeString = channelTypeString;

            _localMaxPacketSize = param.MaxPacketSize;
            _localWindowSize = _localWindowSizeLeft = param.WindowSize;
            _serverMaxPacketSize = serverMaxPacketSize;
            _serverWindowSizeLeft = serverWindowSize;

            _state = State.InitiatedByServer; // SendOpenConfirmation() will change state to "Opened"
        }
Example #2
0
        private Cipher _tCipher;                            //cipher for transmission

        // exec command for SCP
        //private bool _executingExecCmd = false;

        public SSH1Connection(SSHConnectionParameter param, AbstractGranadosSocket s, ISSHConnectionEventReceiver er, string serverversion, string clientversion) : base(param, s, er) {
            _cInfo = new SSH1ConnectionInfo();
            _cInfo._serverVersionString = serverversion;
            _cInfo._clientVersionString = clientversion;
            _shellID = -1;
            _packetReceiver = new SynchronizedPacketReceiver(this);
            _packetBuilder = new SSH1PacketBuilder(_packetReceiver);
        }
Example #3
0
        private readonly object _transmitSync = new object();   // for keeping correct packet order

        internal SSH2Connection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver r, string serverversion, string clientversion)
            : base(param, strm, r) {
            _cInfo = new SSH2ConnectionInfo();
            _cInfo._serverVersionString = serverversion;
            _cInfo._clientVersionString = clientversion;

            _packetReceiver = new SynchronizedPacketReceiver(this);
            _packetBuilder = new SSH2PacketBuilder(_packetReceiver);
        }
Example #4
0
        /// <summary>
        /// Open PTY
        /// </summary>
        /// <param name="param">connection parameters</param>
        /// <returns>true if pty has been opened successfully</returns>
        private bool OpenPTY(SSHConnectionParameter param)
        {
            lock (_stateSync) {
                if (_state != State.Initial) {
                    return false;
                }

                _state = State.WaitStartPTYResponse;
                Monitor.PulseAll(_stateSync);   // notifies state change
            }

            Transmit(
                new SSH1Packet(SSH1PacketType.SSH_CMSG_REQUEST_PTY)
                    .WriteString(param.TerminalName)
                    .WriteInt32(param.TerminalHeight)
                    .WriteInt32(param.TerminalWidth)
                    .WriteInt32(param.TerminalPixelWidth)
                    .WriteInt32(param.TerminalPixelHeight)
                    .Write(new byte[1]) //TTY_OP_END
            );

            Trace("CH[{0}] request PTY : term={1} width={2} height={3} pixelWidth={4} pixelHeight={5}",
                LocalChannel, param.TerminalName,
                param.TerminalWidth, param.TerminalHeight,
                param.TerminalPixelWidth, param.TerminalPixelHeight);

            DataFragment packet = null;
            if (!_receivedPacket.TryGet(ref packet, RESPONSE_TIMEOUT)) {
                RequestFailed();
                return false;
            }

            lock (_stateSync) {
                if (_state == State.StartPTYSuccess) {
                    return true;
                }
            }

            RequestFailed();
            return false;
        }
Example #5
0
        //Tutorial: Connecting to a host and opening a shell
        private static void ConnectAndOpenShell()
        {
            SampleKeyboardInteractiveAuthenticationHandler authHandler = null;
            SSHConnectionParameter f = new SSHConnectionParameter("172.22.1.15", 22, SSHProtocol.SSH2, AuthenticationType.PublicKey, "okajima", "aaa");
            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.RSA, PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };
            f.WindowSize = 0x1000; //this option is ignored with SSH1
            f.KeyboardInteractiveAuthenticationHandlerCreator =
                (connection) => {
                    return (authHandler = new SampleKeyboardInteractiveAuthenticationHandler("aaa"));
                };

            Tracer tracer = new Tracer();

            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            s.Connect(new IPEndPoint(IPAddress.Parse(f.HostName), f.PortNumber)); //22 is the default SSH port

            ISSHConnection conn;

            if (f.AuthenticationType == AuthenticationType.KeyboardInteractive) {
                //Creating a new SSH connection over the underlying socket
                conn = SSHConnection.Connect(s, f, c => new Reader(c), c => new Tracer());
                bool result = authHandler.GetResult();
                Debug.Assert(result == true);
            }
            else {
                //NOTE: if you use public-key authentication, follow this sample instead of the line above:
                //f.AuthenticationType = AuthenticationType.PublicKey;
                f.IdentityFile = "C:\\P4\\tools\\keys\\aaa";
                f.VerifySSHHostKey = (info) => {
                    byte[] h = info.HostKeyFingerPrint;
                    foreach (byte b in h)
                        Debug.Write(String.Format("{0:x2} ", b));
                    return true;
                };

                //Creating a new SSH connection over the underlying socket
                conn = SSHConnection.Connect(s, f, c => new Reader(c), null);
            }

            //Opening a shell
            var ch = conn.OpenShell(channelOperator => new ChannelHandler(channelOperator));

            //you can get the detailed connection information in this way:
            //SSHConnectionInfo ci = _conn.ConnectionInfo;

            //Go to sample shell
            SampleShell(ch);
        }
        //Tutorial: port forwarding
        private static void ConnectSSH2AndPortforwarding()
        {
            SSHConnectionParameter f = new SSHConnectionParameter();
            f.EventTracer = new Tracer(); //to receive detailed events, set ISSHEventTracer
            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            f.Protocol = SSHProtocol.SSH1; //this sample works on both SSH1 and SSH2
            string host_ip = "10.10.9.8"; //<--!!! [TO USERS OF Granados]
            f.UserName = "******";          //<--!!! if you try this sample, edit these values for your environment!
            f.Password = "";              //<--!!!
            s.Connect(new IPEndPoint(IPAddress.Parse(host_ip), 22)); //22 is the default SSH port

            f.Protocol = SSHProtocol.SSH2;

            f.AuthenticationType = AuthenticationType.Password;
            //NOTE: if you use public-key authentication, follow this sample instead of the line above:
            //  f.AuthenticationType = AuthenticationType.PublicKey;
            //  f.IdentityFile = "privatekey.bin";
            //  f.Password = "******";

            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };

            f.WindowSize = 0x1000; //this option is ignored with SSH1

            Reader reader = new Reader(); //simple event receiver

            //Creating a new SSH connection over the underlying socket
            _conn = SSHConnection.Connect(f, reader, s);
            reader._conn = _conn;

            //Local->Remote port forwarding
            SSHChannel ch = _conn.ForwardPort(reader, "www.google.co.jp", 80, "localhost", 0);
            reader._pf = ch;
            while (!reader._ready)
                System.Threading.Thread.Sleep(100); //wait response
            reader._pf.Transmit(Encoding.ASCII.GetBytes("GET / HTTP/1.0\r\n\r\n")); //get the toppage

            //Remote->Local
            // if you want to listen to a port on the SSH server, follow this line:
            //_conn.ListenForwardedPort("0.0.0.0", 10000);

            //NOTE: if you use SSH2, dynamic key exchange feature is supported.
            //((SSH2Connection)_conn).ReexchangeKeys();
        }
        private static void AgentForward()
        {
            SSHConnectionParameter f = new SSHConnectionParameter();
            f.EventTracer = new Tracer(); //to receive detailed events, set ISSHEventTracer
            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            f.Protocol = SSHProtocol.SSH2; //this sample works on both SSH1 and SSH2
            string host_ip = "172.22.1.15"; //<--!!! [TO USERS OF Granados]
            f.UserName = "******";               //<--!!! if you try this sample, edit these values for your environment!
            string password = "";
            s.Connect(new IPEndPoint(IPAddress.Parse(host_ip), 22)); //22 is the default SSH port

            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.RSA, PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };
            f.WindowSize = 0x1000; //this option is ignored with SSH1
            f.AgentForward = new AgentForwardClient();
            Reader reader = new Reader(); //simple event receiver

            AuthenticationType at = AuthenticationType.Password;
            f.AuthenticationType = at;
            f.Password = password;

            //Creating a new SSH connection over the underlying socket
            _conn = SSHConnection.Connect(f, reader, s);
            reader._conn = _conn;

            //Opening a shell
            SSHChannel ch = _conn.OpenShell(reader);
            reader._pf = ch;

            while (!reader._ready)
                Thread.Sleep(100);

            Thread.Sleep(1000);
            ch.Transmit(Encoding.Default.GetBytes("ssh -A -l okajima localhost\r"));

            //Go to sample shell
            SampleShell(reader);
        }
Example #8
0
 public VersionExchangeHandler(SSHConnectionParameter param, AbstractGranadosSocket socket)
     : base(socket) {
     _param = param;
 }
Example #9
0
 internal static DummySSHChannel Create()
 {
     SSHConnectionParameter param = new SSHConnectionParameter();
     DummySSHConnection conn = new DummySSHConnection(param, null, null);
     conn.ChannelCollection.RegisterChannelEventReceiver(null, null);
     return new DummySSHChannel(conn);
 }
Example #10
0
 /// <summary>
 /// Constructor (initiated by server)
 /// </summary>
 public SSH2X11ForwardingChannel(
         IPacketSender<SSH2Packet> packetSender,
         SSHConnectionParameter param,
         SSHProtocolEventManager protocolEventManager,
         uint localChannel,
         uint remoteChannel,
         uint serverWindowSize,
         uint serverMaxPacketSize)
     : base(packetSender, param, protocolEventManager, localChannel, remoteChannel, CHANNEL_TYPE, CHANNEL_TYPE_STRING, serverWindowSize, serverMaxPacketSize)
 {
 }
Example #11
0
 /// <summary>
 /// Constructor (initiated by client)
 /// </summary>
 public SSH2SubsystemChannel(
         IPacketSender<SSH2Packet> packetSender,
         SSHConnectionParameter param,
         SSHProtocolEventManager protocolEventManager,
         uint localChannel,
         string subsystemName)
     : base(packetSender, param, protocolEventManager, localChannel)
 {
     _subsystemName = subsystemName;
 }
Example #12
0
 /// <summary>
 /// Constructor (initiated by client)
 /// </summary>
 public SSH2ShellChannel(
         IPacketSender<SSH2Packet> packetSender,
         SSHConnectionParameter param,
         SSHProtocolEventManager protocolEventManager,
         uint localChannel,
         X11ConnectionManager x11ConnectionManager)
     : base(packetSender, param, protocolEventManager, localChannel)
 {
     _param = param;
     _x11ConnectionManager = x11ConnectionManager;
 }
Example #13
0
 /// <summary>
 /// Constructor (initiated by client)
 /// </summary>
 public SSH2SessionChannel(
         IPacketSender<SSH2Packet> packetSender,
         SSHConnectionParameter param,
         SSHProtocolEventManager protocolEventManager,
         uint localChannel)
     : base(packetSender, param, protocolEventManager, localChannel, CHANNEL_TYPE, CHANNEL_TYPE_STRING)
 {
 }
Example #14
0
        //Tutorial: port forwarding
        private static void ConnectSSH2AndPortforwarding()
        {
            SSHConnectionParameter f = new SSHConnectionParameter("10.10.9.8", 22, SSHProtocol.SSH2, AuthenticationType.Password, "root", "");

            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            s.Connect(new IPEndPoint(IPAddress.Parse(f.HostName), f.PortNumber)); //22 is the default SSH port

            //NOTE: if you use public-key authentication, follow this sample instead of the line above:
            //  f.AuthenticationType = AuthenticationType.PublicKey;
            //  f.IdentityFile = "privatekey.bin";
            //  f.Password = "******";

            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };

            f.WindowSize = 0x1000; //this option is ignored with SSH1

            //Creating a new SSH connection over the underlying socket
            Reader reader = null;
            var conn = SSHConnection.Connect(s, f,
                c => {
                    return reader = new Reader(c);
                },
                c => new Tracer());

            Debug.Assert(reader != null);

            //Local->Remote port forwarding
            ChannelHandler ch = conn.ForwardPort(
                    channelOperator => new ChannelHandler(channelOperator),
                    "www.google.co.jp", 80u, "localhost", 0u);
            while (!reader._ready)
                System.Threading.Thread.Sleep(100); //wait response
            byte[] data = Encoding.ASCII.GetBytes("GET / HTTP/1.0\r\n\r\n");
            ch.Operator.Send(new DataFragment(data, 0, data.Length)); //get the toppage

            //Remote->Local
            // if you want to listen to a port on the SSH server, follow this line:
            //_conn.ListenForwardedPort("0.0.0.0", 10000);

            //NOTE: if you use SSH2, dynamic key exchange feature is supported.
            //((SSH2Connection)_conn).ReexchangeKeys();
        }
Example #15
0
        private static void AgentForward()
        {
            SSHConnectionParameter f = new SSHConnectionParameter("172.22.1.15", 22, SSHProtocol.SSH2, AuthenticationType.Password, "root", "");
            f.EventTracer = new Tracer(); //to receive detailed events, set ISSHEventTracer
            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            s.Connect(new IPEndPoint(IPAddress.Parse(f.HostName), f.PortNumber)); //22 is the default SSH port

            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.RSA, PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };
            f.WindowSize = 0x1000; //this option is ignored with SSH1
            f.AgentForward = new AgentForwardClient();
            Reader reader = new Reader(); //simple event receiver

            //Creating a new SSH connection over the underlying socket
            _conn = SSHConnection.Connect(f, reader, s);
            reader._conn = _conn;

            //Opening a shell
            SSHChannel ch = _conn.OpenShell(reader);
            reader._pf = ch;

            while (!reader._ready)
                Thread.Sleep(100);

            Thread.Sleep(1000);
            ch.Transmit(Encoding.Default.GetBytes("ssh -A -l okajima localhost\r"));

            //Go to sample shell
            SampleShell(reader);
        }
Example #16
0
 /// <summary>
 /// Constructor (initiated by client)
 /// </summary>
 public SSH2ExecChannel(
         IPacketSender<SSH2Packet> packetSender,
         SSHConnectionParameter param,
         SSHProtocolEventManager protocolEventManager,
         uint localChannel,
         string command)
     : base(packetSender, param, protocolEventManager, localChannel)
 {
     _command = command;
 }
Example #17
0
        //Tutorial: Connecting to a host and opening a shell
        private static void ConnectAndOpenShell()
        {
            SSHConnectionParameter f = new SSHConnectionParameter("172.22.1.15", 22, SSHProtocol.SSH2, AuthenticationType.PublicKey, "okajima", "aaa");
            f.EventTracer = new Tracer(); //to receive detailed events, set ISSHEventTracer
            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.RSA, PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };
            f.WindowSize = 0x1000; //this option is ignored with SSH1
            Reader reader = new Reader(); //simple event receiver

            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            s.Connect(new IPEndPoint(IPAddress.Parse(f.HostName), f.PortNumber)); //22 is the default SSH port

            if (f.AuthenticationType == AuthenticationType.KeyboardInteractive) {
                //Creating a new SSH connection over the underlying socket
                _conn = SSHConnection.Connect(f, reader, s);
                reader._conn = _conn;
                Debug.Assert(_conn.AuthenticationResult == AuthenticationResult.Prompt);
                AuthenticationResult r = ((SSH2Connection)_conn).DoKeyboardInteractiveAuth(new string[] { f.Password });
                Debug.Assert(r == AuthenticationResult.Success);
            }
            else {
                //NOTE: if you use public-key authentication, follow this sample instead of the line above:
                //f.AuthenticationType = AuthenticationType.PublicKey;
                f.IdentityFile = "C:\\P4\\tools\\keys\\aaa";
                f.VerifySSHHostKey = (info) => {
                    byte[] h = info.HostKeyFingerPrint;
                    foreach (byte b in h)
                        Debug.Write(String.Format("{0:x2} ", b));
                    return true;
                };

                //Creating a new SSH connection over the underlying socket
                _conn = SSHConnection.Connect(f, reader, s);
                reader._conn = _conn;
            }

            //Opening a shell
            SSHChannel ch = _conn.OpenShell(reader);
            reader._pf = ch;

            //you can get the detailed connection information in this way:
            //SSHConnectionInfo ci = _conn.ConnectionInfo;

            //Go to sample shell
            SampleShell(reader);
        }
Example #18
0
        /// <summary>
        /// Constructor (initiated by client)
        /// </summary>
        public SSH2ChannelBase(
                IPacketSender<SSH2Packet> packetSender,
                SSHConnectionParameter param,
                SSHProtocolEventManager protocolEventManager,
                uint localChannel,
                ChannelType channelType,
                string channelTypeString)
        {
            _packetSender = packetSender;
            _protocolEventManager = protocolEventManager;
            LocalChannel = localChannel;
            RemoteChannel = 0;
            ChannelType = channelType;
            ChannelTypeString = channelTypeString;

            _localMaxPacketSize = param.MaxPacketSize;
            _localWindowSize = _localWindowSizeLeft = param.WindowSize;
            _serverMaxPacketSize = 0;
            _serverWindowSizeLeft = 0;

            _state = State.InitiatedByClient; // receiving SSH_MSG_CHANNEL_OPEN_CONFIRMATION will change state to "Opened"
        }
Example #19
0
 public KeyExchanger(SSH2Connection con, byte[] sessionID) {
     _connection = con;
     _param = con.Param;
     _cInfo = (SSH2ConnectionInfo)con.ConnectionInfo;
     _sessionID = sessionID;
     _status = Status.INITIAL;
 }
Example #20
0
 /// <summary>
 /// Constructor (initiated by client)
 /// </summary>
 public SSH2LocalPortForwardingChannel(
         IPacketSender<SSH2Packet> packetSender,
         SSHConnectionParameter param,
         SSHProtocolEventManager protocolEventManager,
         uint localChannel,
         string remoteHost,
         uint remotePort,
         string originatorIp,
         uint originatorPort)
     : base(packetSender, param, protocolEventManager, localChannel, CHANNEL_TYPE, CHANNEL_TYPE_STRING)
 {
     _localWindowSize = param.WindowSize;
     _localMaxPacketSize = param.WindowSize;
     _remoteHost = remoteHost;
     _remotePort = remotePort;
     _originatorIp = originatorIp;
     _originatorPort = originatorPort;
 }
Example #21
0
 internal DummySSHConnection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver receiver)
     : base(param, strm, receiver)
 {
 }
Example #22
0
 /// <summary>
 /// Starts a command
 /// </summary>
 /// <param name="param">connection parameters</param>
 /// <param name="command">command line to execute</param>
 public void ExecCommand(SSHConnectionParameter param, string command)
 {
     Task.Run(() => DoExecCommand(param, command));
 }
Example #23
0
 // exec command for SCP
 //private bool _executingExecCmd = false;
 public SSH1Connection(SSHConnectionParameter param, IGranadosSocket s, ISSHConnectionEventReceiver er, string serverVersion, string clientVersion)
     : base(param, s, er)
 {
     _cInfo = new SSH1ConnectionInfo(param.HostName, param.PortNumber, serverVersion, clientVersion);
     _shellID = -1;
     _packetReceiver = new SynchronizedPacketReceiver(this);
     _packetizer = new SSH1Packetizer(_packetReceiver);
 }
Example #24
0
        /// <summary>
        /// Starts a shell
        /// </summary>
        /// <param name="param">connection parameters</param>
        /// <returns>true if shell has been started successfully</returns>
        public bool ExecShell(SSHConnectionParameter param)
        {
            if (!OpenPTY(param)) {
                return false;
            }

            lock (_stateSync) {
                Transmit(
                    new SSH1Packet(SSH1PacketType.SSH_CMSG_EXEC_SHELL)
                );
                _state = State.Established;
                Monitor.PulseAll(_stateSync);   // notifies state change
            }

            Trace("CH[{0}] execute shell", LocalChannel);

            DataFragment empty = new DataFragment(0);
            Handler.OnEstablished(empty);

            lock (_stateSync) {
                _state = State.Ready;
                Monitor.PulseAll(_stateSync);   // notifies state change
            }

            Handler.OnReady();

            return true;
        }
        //Tutorial: Connecting to a host and opening a shell
        private static void ConnectAndOpenShell()
        {
            SSHConnectionParameter f = new SSHConnectionParameter();
            f.EventTracer = new Tracer(); //to receive detailed events, set ISSHEventTracer
            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            f.Protocol = SSHProtocol.SSH2; //this sample works on both SSH1 and SSH2
            string host_ip = "172.22.1.15"; //<--!!! [TO USERS OF Granados]
            f.UserName = "******";               //<--!!! if you try this sample, edit these values for your environment!
            string password = "******";
            s.Connect(new IPEndPoint(IPAddress.Parse(host_ip), 22)); //22 is the default SSH port

            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.RSA, PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };
            f.WindowSize = 0x1000; //this option is ignored with SSH1
            Reader reader = new Reader(); //simple event receiver

            AuthenticationType at = AuthenticationType.PublicKey;
            f.AuthenticationType = at;

            if (at == AuthenticationType.KeyboardInteractive) {
                //Creating a new SSH connection over the underlying socket
                _conn = SSHConnection.Connect(f, reader, s);
                reader._conn = _conn;
                Debug.Assert(_conn.AuthenticationResult == AuthenticationResult.Prompt);
                AuthenticationResult r = ((SSH2Connection)_conn).DoKeyboardInteractiveAuth(new string[] { password });
                Debug.Assert(r == AuthenticationResult.Success);
            }
            else {
                //NOTE: if you use public-key authentication, follow this sample instead of the line above:
                //f.AuthenticationType = AuthenticationType.PublicKey;
                f.IdentityFile = "C:\\P4\\tools\\keys\\aaa";
                f.Password = password;
                f.KeyCheck = delegate(SSHConnectionInfo info) {
                    byte[] h = info.HostKeyMD5FingerPrint();
                    foreach (byte b in h)
                        Debug.Write(String.Format("{0:x2} ", b));
                    return true;
                };

                //Creating a new SSH connection over the underlying socket
                _conn = SSHConnection.Connect(f, reader, s);
                reader._conn = _conn;
            }

            //Opening a shell
            SSHChannel ch = _conn.OpenShell(reader);
            reader._pf = ch;

            //you can get the detailed connection information in this way:
            SSHConnectionInfo ci = _conn.ConnectionInfo;

            //Go to sample shell
            SampleShell(reader);
        }
Example #26
0
        /// <summary>
        /// Starts a command
        /// </summary>
        /// <param name="param">connection parameters</param>
        /// <param name="command">command line to execute</param>
        private void DoExecCommand(SSHConnectionParameter param, string command)
        {
            if (!OpenPTY(param)) {
                return;
            }

            lock (_stateSync) {
                Transmit(
                    new SSH1Packet(SSH1PacketType.SSH_CMSG_EXEC_CMD)
                        .WriteString(command)
                );
                _state = State.Established;
                Monitor.PulseAll(_stateSync);   // notifies state change
            }

            Trace("CH[{0}] execute command : command={1}", LocalChannel, command);

            DataFragment empty = new DataFragment(0);
            Handler.OnEstablished(empty);

            lock (_stateSync) {
                _state = State.Ready;
                Monitor.PulseAll(_stateSync);   // notifies state change
            }

            Handler.OnReady();
        }
        // This method uses SCP protocol.
        private static void ScpCommand(string[] args)
        {
            ScpParameter scp_param = new ScpParameter();
            #if true //OKAJIMA
            #if true
            scp_param.Direction = SCPCopyDirection.LocalToRemote;
            scp_param.RemoteFilename = "test.txt";
            scp_param.LocalSource = new ScpLocalSource("C:\\IOPort\\test.txt");
            #else
            scp_param.Direction = SCPCopyDirection.RemoteToLocal;
            scp_param.RemoteFilename = "hiro.jpg";
            scp_param.LocalSource = new ScpLocalSource("C:\\IOPort\\hiro.jpg");
            #endif
            //string host_ip;
            //string username, password;

            SSHConnectionParameter f = new SSHConnectionParameter();
            f.EventTracer = new Tracer(); //to receive detailed events, set ISSHEventTracer
            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            f.Protocol = SSHProtocol.SSH2;
            f.UserName = "******";          //<--!!! if you try this sample, edit these values for your environment!
            f.Password = "******";              //<--!!!
            f.AuthenticationType = AuthenticationType.Password;
            s.Connect(new IPEndPoint(IPAddress.Parse("172.22.1.2"), 22)); //22 is the default SSH port

            SSHConnection conn = SSHConnection.Connect(f, new Reader(), s);
            conn.AutoDisconnect = false; //auto close is disabled for multiple scp operations
            conn.ExecuteSCP(scp_param);

            conn.Disconnect("");
            #endif
            #if HIRATA
            // check argument
            if (args.Length != 6) {
                Console.WriteLine("Usage: ScpCommand <server:port> <username> <password> to|from <src_file> <dst_file>");
                Environment.Exit(0);
            }

            // test pattern
            int test = 103;

            if (test == 0) {
                args[0] = "192.168.1.2";
                args[1] = "yutaka";
                args[2] = "yutaka";
                args[3] = "to";
                args[4] = "hoge6.txt";
                args[5] = "hoge6s.txt";
            }
            if (test == 1) {
                args[0] = "192.168.1.2";
                args[1] = "yutaka";
                args[2] = "yutaka";
                args[3] = "to";
                args[4] = "hoge28k.txt";
                args[5] = "hoge28ks.txt";
            }
            if (test == 2) {
                args[0] = "192.168.1.2";
                args[1] = "yutaka";
                args[2] = "yutaka";
                args[3] = "to";
                args[4] = null;   // use Local Memory
                args[5] = "hogeLM.txt";
            }
            if (test == 3) { // big file transfer
                args[0] = "192.168.1.2";
                args[1] = "yutaka";
                args[2] = "yutaka";
                args[3] = "to";
                args[4] = "bigfile.bin";
                args[5] = "bigfile.bin";
            }

            if (test == 100) {
                args[0] = "192.168.1.2";
                args[1] = "yutaka";
                args[2] = "yutaka";
                args[3] = "from";
                args[4] = "hoge6.txt";
                args[5] = "hoge6c.txt";
            }
            if (test == 101) {
                args[0] = "192.168.1.2";
                args[1] = "yutaka";
                args[2] = "yutaka";
                args[3] = "from";
                args[4] = "hoge28k.txt";
                args[5] = "hoge28kc.txt";
            }
            if (test == 102) {
                args[0] = "192.168.1.2";
                args[1] = "yutaka";
                args[2] = "yutaka";
                args[3] = "from";
                args[4] = "hoge6.txt";
                //args[4] = "hoge28k.txt";
                args[5] = null;   // use Local Memory
            }
            if (test == 103) {  // big file transfer
                args[0] = "192.168.1.2";
                args[1] = "yutaka";
                args[2] = "yutaka";
                args[3] = "from";
                args[4] = "bigfile.bin";
                args[5] = "bigfilec.bin";
            }

            host_ip = args[0];
            username = args[1];
            password = args[2];

            // setup SCP parameter
            if (args[3] == "to") {  // Local to Remote
                if (args[5] == null || args[5] == "") {
                    param.RemoteFilename = null;
                }
                else {
                    param.RemoteFilename = args[5];  // remote file
                }

                // �]�����̎w��i���[�J���t�@�C������у��[�J����������I��j
                if (args[4] != null) {
                    // ���[�J���t�@�C���̓]��
                    param.LocalSource = args[4]; // src file

                }
                else {
                    // �I�����C���������̓]��
                    //param.IoStream = new MemoryStream(256);
                    param.IoStream = new MemoryStream(8192);
                    for (int i = 0; i < 8192; i++) {
                        param.IoStream.WriteByte((byte)i);
                    }
                    param.IoStream.Seek(0, SeekOrigin.Begin);
                }
                param.Direction = true;

                param.Permission = "0666";

            }
            else {  // Remote to Local
                param.RemoteFilename = args[4]; // remote file

                // �]�����̎w��i���[�J���t�@�C������у��[�J����������I��j
                if (args[5] != null) {
                    // ���[�J���t�@�C���̓]��
                    param.LocalSource = args[5];
                }
                else {
                    // �I�����C���������̓]��
                    param.IoStream = null;
                }
                param.Direction = false;
            }

            // connect to server with SSH protocol
            SSHConnectionParameter f = new SSHConnectionParameter();
            f.EventTracer = new Tracer(); //to receive detailed events, set ISSHEventTracer
            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            f.Protocol = SSHProtocol.SSH2; //this sample works on both SSH1 and SSH2
            f.UserName = username;          //<--!!! if you try this sample, edit these values for your environment!
            f.Password = password;              //<--!!!
            s.Connect(new IPEndPoint(IPAddress.Parse(host_ip), 22)); //22 is the default SSH port

            f.AuthenticationType = AuthenticationType.Password;
            //NOTE: if you use public-key authentication, follow this sample instead of the line above:
            //  f.AuthenticationType = AuthenticationType.PublicKey;
            //  f.IdentityFile = "privatekey.bin";
            //  f.Password = "******";

            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };

            //this option is ignored with SSH1
            f.WindowSize = 0x1000; //NG: ERROR: MAC mismatch
            //f.WindowSize = 0x800; //NG
            //f.WindowSize = 0x30000; //NG
            //f.WindowSize = 0x400; //OK
            //f.CheckMACError = false; //NG: unexpected channel pt=SSH_MSG_CHANNEL_DATA local_channel=33243

            /* USER OPTION */
            //param.CancelTransfer = true;  // cancel flag
            param.ProgressCallback = delegate() {
                Debug.Write("*");
            };   // callback function

            if (SSHConnection.SCPExecute(param, f, s)) {
                Debug.WriteLine("scp success!");

                if (param.Direction == false) {
                    if (param.IoStream != null) {
                        Debug.Write("IO Stream: ");
                        for (int i = 0; i < param.IoStream.Length; i++) {
                            byte b = (byte)param.IoStream.ReadByte();
                            Debug.Write(b.ToString("x2") + " ");
                        }
                        Debug.WriteLine("");
                    }
                }
            }
            else {
                Debug.WriteLine("scp failure: " + param.ErrorMessage);
            }

            #endif
        }
Example #28
0
        private static void AgentForward()
        {
            SSHConnectionParameter f = new SSHConnectionParameter("172.22.1.15", 22, SSHProtocol.SSH2, AuthenticationType.Password, "root", "");

            Tracer tracer = new Tracer();

            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            s.Connect(new IPEndPoint(IPAddress.Parse(f.HostName), f.PortNumber)); //22 is the default SSH port

            //former algorithm is given priority in the algorithm negotiation
            f.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.RSA, PublicKeyAlgorithm.DSA };
            f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };
            f.WindowSize = 0x1000; //this option is ignored with SSH1
            f.AgentForwardingAuthKeyProvider = new AgentForwardingAuthKeyProvider();

            //Creating a new SSH connection over the underlying socket
            Reader reader = null;
            var conn = SSHConnection.Connect(s, f,
                            c => {
                                return reader = new Reader(c);
                            },
                            c => new Tracer()
                       );
            Debug.Assert(reader != null);

            //Opening a shell
            var ch = conn.OpenShell(channelOperator => new ChannelHandler(channelOperator));

            while (!reader._ready)
                Thread.Sleep(100);

            Thread.Sleep(1000);
            byte[] data = Encoding.Default.GetBytes("ssh -A -l okajima localhost\r");
            ch.Operator.Send(new DataFragment(data, 0, data.Length));

            //Go to sample shell
            SampleShell(ch);
        }