/// <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"
}
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);
}
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);
}
internal static DummySSHChannel Create()
{
SSHConnectionParameter param = new SSHConnectionParameter();
DummySSHConnection conn = new DummySSHConnection(param, null, null);
conn.ChannelCollection.RegisterChannelEventReceiver(null, null);
return new DummySSHChannel(conn);
}
/// <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));
}
//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);
}
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);
}
/// <summary>
/// Connect to remote host:port over SSH tunnel
/// </summary>
public void Connect(string host, int port)
{
try
{
//remember remote target
m_RemoteTarget = new IPEndPoint(ResolveHost(host), port);
//connect to SSH server
m_Client.Connect(new IPEndPoint(m_RemoteTarget.Address, SSHServerPort));
//get password from user
var pass = ErlTransportPasswordSource.GetPassword(this, NodeName, SSHUserName);
//set params
var param = new SSHConnectionParameter();
param.EventTracer = this; //to receive detailed events
param.UserName = SSHUserName;
param.Password = pass;
param.Protocol = SSHProtocol.SSH2;
param.AuthenticationType = (AuthenticationType)Enum.Parse(typeof(SSH.AuthenticationType), SSHAuthenticationType);
if (param.AuthenticationType == AuthenticationType.PublicKey)
{
param.IdentityFile = SSHPrivateKeyFilePath;
}
//former algorithm is given priority in the algorithm negotiation
param.PreferableHostKeyAlgorithms = new PublicKeyAlgorithm[] { PublicKeyAlgorithm.RSA, PublicKeyAlgorithm.DSA };
param.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES, CipherAlgorithm.AES192CTR, CipherAlgorithm.AES256CTR, CipherAlgorithm.AES128CTR };
param.WindowSize = 0x1000; //this option is ignored with SSH1
//Creating a new SSH connection over the underlying socket
m_Connection = SSHConnection.Connect(param, this, m_Client);
m_Connection.AutoDisconnect = true;
m_IsChannelReady = false;
//Local->Remote port forwarding (we use localhost:0 as local port, because local port is not required for us, we will use this tunnel directly)
m_Channel = m_Connection.ForwardPort(this, host, port, "localhost", 0);
var deadLine = DateTime.Now.AddMilliseconds(SSHTunnelCreationTimeout);
while (!m_IsChannelReady && deadLine > DateTime.Now)
{
System.Threading.Thread.Sleep(50); //wait response
}
//if timeouted - throw exception
if (!m_IsChannelReady && deadLine < DateTime.Now)
{
throw new ErlException(ERL_CREATE_SSH_TUNNEL_ERROR);
}
//create network stream
m_Stream = new SshTunnelStream(m_Channel);
//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();
}
catch (Exception ex)
{
OnTrace(ErlTraceLevel.Ctrl, Direction.Inbound, ex.Message);
throw;
}
}
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);
}
public static TelnetConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, StreamSocket underlying_socket)
{
return(new TelnetConnection(param, receiver, underlying_socket));
}
internal DummySSHConnection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver receiver)
: base(param, strm, receiver)
{
}
public void CheckFresh()
{
//if (ThreadManager.IsRunning == false) return;
try
{
string[] cols = row.Split('|');
Host = cols[0].Trim();
User = cols[1].Trim();
Pass = cols[2].Trim();
if (cols.Count() == 3)
{
Country = "UNKNOWN";
}
else
{
Country = cols[3].Trim();
}
_f = new SSHConnectionParameter();
_f.UserName = User;
_f.Password = Pass;
_f.Protocol = SSHProtocol.SSH2;
_f.AuthenticationType = AuthenticationType.Password;
_f.WindowSize = 0x1000;
_reader = new Reader();
_reader.TimeoutSeconds = TimeoutSeconds;
_reader.passControl = new Reader.PassControl(passControl);
_reader._country = Country;
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//s.Blocking = false;
_socket.SendTimeout = TimeoutSeconds * 1000;
_socket.ReceiveTimeout = TimeoutSeconds * 1000;
_socket.Connect(new IPEndPoint(IPAddress.Parse(Host), DefaultPort));
new Thread(new ThreadStart(SetSSHConnectionTimeout)).Start();
_conn = SSHConnection.Connect(_f, _reader, _socket);
if (SSHConnectTimeout)
{
throw new Exception("SSH Connect Timeout");
}
_reader._conn = _conn;
SSHChannel ch = _conn.ForwardPort(_reader, "ipinfo.io", 80, "localhost", 80);
_reader._pf = ch;
int seconds = TimeoutSeconds;
while (_reader._ready == false && seconds > 0)
{
seconds--; Thread.Sleep(1000);
}
if (_reader._ready == false && seconds <= 0)
{
throw new Exception("Reader._ready timeout");
}
_reader.LineIndex = LineIndex;
_reader.Host = Host;
_reader.User = User;
_reader.Pass = Pass;
new Thread(new ThreadStart(_reader.SetHTTPRequestTimeout)).Start();
_reader._pf.Transmit(Encoding.ASCII.GetBytes("GET /json HTTP/1.1\r\nHost:ipinfo.io\r\n\r\n")); //http://ipinfo.io/json
}
catch (Exception ex)
{
passControl(LineIndex, false, "", ex.Message);
}
}
//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();
}
//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);
}
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);
}
public VersionExchangeHandler(SSHConnectionParameter param, AbstractGranadosSocket socket)
: base(socket) {
_param = param;
}
public VersionExchangeHandler(SSHConnectionParameter param, AbstractGranadosSocket socket)
: base(socket)
{
_param = param;
}
/// <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)
{
}
//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();
}
/// <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;
}
/// <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;
}
/// <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;
}
//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);
}
/// <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)
{
}
static void Main(string[] args)
{
/*
* string cn = System.Threading.Thread.CurrentThread.CurrentUICulture.Name;
* string t1 = Routrek.SSHC.Strings.GetString("NotSSHServer");
* System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("ja");
* Routrek.SSHC.Strings.Reload();
* string t2 = Routrek.SSHC.Strings.GetString("NotSSHServer");
*/
#if false //RSA keygen
//RSA KEY GENERATION TEST
byte[] testdata = Encoding.ASCII.GetBytes("CHRISTIAN VIERI");
RSAKeyPair kp = RSAKeyPair.GenerateNew(2048, new Random());
byte[] sig = kp.Sign(testdata);
kp.Verify(sig, testdata);
new SSH2UserAuthKey(kp).WritePublicPartInOpenSSHStyle(new FileStream("C:\\IOPort\\newrsakey", FileMode.Create));
//SSH2UserAuthKey newpk = SSH2PrivateKey.FromSECSHStyleFile("C:\\IOPort\\newrsakey", "nedved");
#endif
#if false //DSA keygen
//DSA KEY GENERATION TEST
byte[] testdata = Encoding.ASCII.GetBytes("CHRISTIAN VIERI 0000");
DSAKeyPair kp = DSAKeyPair.GenerateNew(2048, new Random());
byte[] sig = kp.Sign(testdata);
kp.Verify(sig, testdata);
new SSH2UserAuthKey(kp).WritePublicPartInOpenSSHStyle(new FileStream("C:\\IOPort\\newdsakey", FileMode.Create));
//SSH2PrivateKey newpk = SSH2PrivateKey.FromSECSHStyleFile("C:\\IOPort\\newdsakey", "nedved");
#endif
SSHConnectionParameter f = new SSHConnectionParameter();
f.UserName = "******";
#if false //SSH1
//SSH1
f.Password = "";
f.Protocol = SSHProtocol.SSH2;
f.AuthenticationType = AuthenticationType.Password;
f.PreferableCipherAlgorithms = new CipherAlgorithm[] { CipherAlgorithm.Blowfish, CipherAlgorithm.TripleDES };
#else //SSH2
f.Password = "";
f.Protocol = SSHProtocol.SSH2;
f.AuthenticationType = AuthenticationType.Password;
f.WindowSize = 0x1000;
#endif
Reader reader = new Reader();
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//s.Blocking = false;
s.Connect(new IPEndPoint(IPAddress.Parse("192.168.1.1"), 22));
_conn = SSHConnection.Connect(f, reader, s);
reader._conn = _conn;
#if false //Remote->Local
_conn.ListenForwardedPort("0.0.0.0", 29472);
#elif false //Local->Remote
SSHChannel ch = _conn.ForwardPort(reader, "www.yahoo.co.jp", 80, "localhost", 0);
reader._pf = ch;
while (!reader._ready)
{
System.Threading.Thread.Sleep(100);
}
reader._pf.Transmit(Encoding.ASCII.GetBytes("GET / HTTP/1.0\r\n\r\n"));
#elif false //SSH over SSH
f.Password = "******";
SSHConnection con2 = _conn.OpenPortForwardedAnotherConnection(f, reader, "kuromatsu", 22);
reader._conn = con2;
SSHChannel ch = con2.OpenShell(reader);
reader._pf = ch;
#else //normal shell
SSHChannel ch = _conn.OpenShell(reader);
reader._pf = ch;
#endif
//Debug.WriteLine(_conn.ConnectionInfo.DumpHostKeyInKnownHostsStyle());
SSHConnectionInfo ci = _conn.ConnectionInfo;
Thread.Sleep(1000);
//((SSH2Connection)_conn).ReexchangeKeys();
byte[] b = new byte[1];
while (true)
{
int input = System.Console.Read();
b[0] = (byte)input;
//Debug.WriteLine(input);
reader._pf.Transmit(b);
}
}
/// <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;
}
// 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
}
// 転送元の指定（ローカルファイルおよびローカルメモリを選択）
if (args[4] != null)
{
// ローカルファイルの転送
param.LocalSource = args[4]; // src file
}
else
{
// オンラインメモリの転送
//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
// 転送元の指定（ローカルファイルおよびローカルメモリを選択）
if (args[5] != null)
{
// ローカルファイルの転送
param.LocalSource = args[5];
}
else
{
// オンラインメモリの転送
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
}
/// <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"
}
public KeyExchanger(SSH2Connection con, byte[] sessionID) {
_connection = con;
_param = con.Param;
_cInfo = (SSH2ConnectionInfo)con.ConnectionInfo;
_sessionID = sessionID;
_status = Status.INITIAL;
}
/// <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;
}
internal DummySSHConnection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver receiver)
: base(param, strm, receiver)
{
}
public bool CheckFresh(string SSH, int timeout)
{
bool flag;
try
{
string[] strArrays = SSH.Split(new char[] { '|' });
this.Host = strArrays[0].Trim();
this.User = strArrays[1].Trim();
this.Pass = strArrays[2].Trim();
this._f = new SSHConnectionParameter()
{
UserName = this.User,
Password = this.Pass,
Protocol = SSHProtocol.SSH2,
AuthenticationType = AuthenticationType.Password,
WindowSize = 4096
};
this._reader = new Reader();
this._socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
SendTimeout = timeout,
ReceiveTimeout = timeout
};
this._socket.Connect(new IPEndPoint(IPAddress.Parse(this.Host), 22));
SshChecker._sshTimeOut = timeout;
(new Thread(new ThreadStart(this.SetSSHConnectionTimeout))).Start();
this._conn = SSHConnection.Connect(this._f, this._reader, this._socket);
if (this.SSHConnectTimeout)
{
throw new Exception("SSH Connect Timeout");
}
this._reader._conn = this._conn;
SSHChannel sSHChannel = this._conn.ForwardPort(this._reader, "ipinfo.io", 80, "localhost", 80);
this._reader._pf = sSHChannel;
int num = timeout;
while (true)
{
if ((this._reader._ready ? true : num <= 0))
{
break;
}
num--;
Thread.Sleep(1000);
}
if ((this._reader._ready ? false : num <= 0))
{
throw new Exception("Reader._ready timeout");
}
this._reader.Host = this.Host;
this._reader.User = this.User;
this._reader.Pass = this.Pass;
this._reader.SetHTTPRequestTimeout();
SshChecker.checkDone = false;
this._reader._pf.Transmit(Encoding.ASCII.GetBytes("GET /json HTTP/1.1\r\nHost:ipinfo.io\r\n\r\n"));
DateTime now = DateTime.Now;
while (!SshChecker.checkDone)
{
Thread.Sleep(100);
if ((DateTime.Now - now).TotalSeconds > (double)timeout)
{
throw new Exception("Request timeout");
}
}
if (!SshChecker.isFresh)
{
flag = false;
return(flag);
}
}
catch (Exception exception)
{
flag = false;
return(flag);
}
flag = true;
return(flag);
}
protected override void Negotiate()
{
ITerminalParameter term = (ITerminalParameter)_destination.GetAdapter(typeof(ITerminalParameter));
ITCPParameter tcp = (ITCPParameter)_destination.GetAdapter(typeof(ITCPParameter));
SSHTerminalConnection terminalConnection = new SSHTerminalConnection(_destination);
SSHConnectionParameter con =
new SSHConnectionParameter(
tcp.Destination,
tcp.Port,
_destination.Method,
_destination.AuthenticationType,
_destination.Account,
_destination.PasswordOrPassphrase);
#if DEBUG
// con.EventTracer = new SSHDebugTracer();
#endif
con.Protocol = _destination.Method;
con.CheckMACError = PEnv.Options.SSHCheckMAC;
con.UserName = _destination.Account;
con.Password = _destination.PasswordOrPassphrase;
con.AuthenticationType = _destination.AuthenticationType;
con.IdentityFile = _destination.IdentityFileName;
con.TerminalWidth = term.InitialWidth;
con.TerminalHeight = term.InitialHeight;
con.TerminalName = term.TerminalType;
con.WindowSize = PEnv.Options.SSHWindowSize;
con.Timeouts.ResponseTimeout = PEnv.Options.SSHResponseTimeout;
con.PreferableCipherAlgorithms =
LocalSSHUtil.AppendMissingCipherAlgorithm(
LocalSSHUtil.ParseCipherAlgorithm(PEnv.Options.CipherAlgorithmOrder));
con.PreferableHostKeyAlgorithms =
LocalSSHUtil.AppendMissingPublicKeyAlgorithm(
LocalSSHUtil.ParsePublicKeyAlgorithm(PEnv.Options.HostKeyAlgorithmOrder));
con.AgentForwardingAuthKeyProvider = _destination.AgentForwardingAuthKeyProvider;
con.X11ForwardingParams = _destination.X11Forwarding;
if (_keycheck != null)
{
con.VerifySSHHostKey = (info) => {
return(_keycheck.Vefiry(info));
};
}
con.KeyboardInteractiveAuthenticationHandlerCreator =
sshconn => terminalConnection.GetKeyboardInteractiveAuthenticationHandler();
ISSHProtocolEventLogger protocolEventLogger;
if (ProtocolsPlugin.Instance.ProtocolOptions.LogSSHEvents)
{
protocolEventLogger = new SSHEventTracer(tcp.Destination);
}
else
{
protocolEventLogger = null;
}
var connection = SSHConnection.Connect(_socket, con,
sshconn => terminalConnection.ConnectionEventReceiver,
sshconn => protocolEventLogger);
if (PEnv.Options.RetainsPassphrase && _destination.AuthenticationType != AuthenticationType.KeyboardInteractive)
{
ProtocolsPlugin.Instance.PassphraseCache.Add(tcp.Destination, _destination.Account, _destination.PasswordOrPassphrase); //接続成功時のみセット
}
//_destination.PasswordOrPassphrase = ""; 接続の複製のためにここで消さずに残しておく
terminalConnection.AttachTransmissionSide(connection, connection.AuthenticationStatus);
_result = terminalConnection;
}
/// <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));
}
// 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);
}
/// <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);
}
/// <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
}
protected override void Negotiate()
{
ITerminalParameter term = (ITerminalParameter)_destination.GetAdapter(typeof(ITerminalParameter));
ITCPParameter tcp = (ITCPParameter)_destination.GetAdapter(typeof(ITCPParameter));
SSHTerminalConnection terminalConnection = new SSHTerminalConnection(_destination);
SSHConnectionParameter con =
new SSHConnectionParameter(
tcp.Destination,
tcp.Port,
_destination.Method,
_destination.AuthenticationType,
_destination.Account,
_destination.PasswordOrPassphrase);
#if DEBUG
// con.EventTracer = new SSHDebugTracer();
#endif
con.Protocol = _destination.Method;
con.CheckMACError = PEnv.Options.SSHCheckMAC;
con.UserName = _destination.Account;
con.Password = _destination.PasswordOrPassphrase;
con.AuthenticationType = _destination.AuthenticationType;
con.IdentityFile = _destination.IdentityFileName;
con.TerminalWidth = term.InitialWidth;
con.TerminalHeight = term.InitialHeight;
con.TerminalName = term.TerminalType;
con.WindowSize = PEnv.Options.SSHWindowSize;
con.Timeouts.ResponseTimeout = PEnv.Options.SSHResponseTimeout;
con.PreferableCipherAlgorithms =
LocalSSHUtil.AppendMissingCipherAlgorithm(
LocalSSHUtil.ParseCipherAlgorithm(PEnv.Options.CipherAlgorithmOrder));
con.PreferableHostKeyAlgorithms =
LocalSSHUtil.AppendMissingPublicKeyAlgorithm(
LocalSSHUtil.ParsePublicKeyAlgorithm(PEnv.Options.HostKeyAlgorithmOrder));
con.AgentForwardingAuthKeyProvider = _destination.AgentForwardingAuthKeyProvider;
con.X11ForwardingParams = _destination.X11Forwarding;
if (_keycheck != null)
{
con.VerifySSHHostKey = (info) => {
return(_keycheck.Vefiry(info));
};
}
con.KeyboardInteractiveAuthenticationHandlerCreator =
sshconn => terminalConnection.GetKeyboardInteractiveAuthenticationHandler();
ISSHProtocolEventLogger protocolEventLogger;
if (ProtocolsPlugin.Instance.ProtocolOptions.LogSSHEvents)
{
protocolEventLogger = new SSHEventTracer(tcp.Destination);
}
else
{
protocolEventLogger = null;
}
var connection = SSHConnection.Connect(_socket, con,
sshconn => terminalConnection.ConnectionEventReceiver,
sshconn => protocolEventLogger);
// Note: password must not be cleared here. it will be required when duplicating connection later.
// The login settings was accepted.
// No need to ask a password on the new attempt to login from the shortcut functionality.
_destination.LetUserInputPassword = false;
terminalConnection.AttachTransmissionSide(connection, connection.AuthenticationStatus);
_result = terminalConnection;
}
