/// <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);
}
/// <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;
}
//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);
}
public VersionExchangeHandler(SSHConnectionParameter param, AbstractGranadosSocket socket)
: base(socket) {
_param = param;
}
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>
/// 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)
{
}
/// <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;
}
/// <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>
/// 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("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();
}
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>
/// 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;
}
//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 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)
{
}
/// <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
}
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);
}
