private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH1DataReader reader)
{
int server_channel = reader.ReadInt32();
string host = Encoding.ASCII.GetString(reader.ReadString());
int port = reader.ReadInt32();
SSH1DataWriter writer = new SSH1DataWriter();
PortForwardingCheckResult result = receiver.CheckPortForwardingRequest(host, port, "", 0);
if (result.allowed)
{
int local_id = _channel_collection.RegisterChannelEventReceiver(null, result.channel).LocalID;
_eventReceiver.EstablishPortforwarding(result.channel, new SSH1Channel(this, ChannelType.ForwardedRemoteToLocal, local_id, server_channel));
writer.WriteInt32(server_channel);
writer.WriteInt32(local_id);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION, writer.ToByteArray());
p.WriteTo(_stream, _tCipher);
}
else
{
writer.WriteInt32(server_channel);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE, writer.ToByteArray());
p.WriteTo(_stream, _tCipher);
}
}
/**
* resizes the size of terminal
*/
public override void ResizeTerminal(int width, int height, int pixel_width, int pixel_height)
{
SSH1DataWriter writer = new SSH1DataWriter();
writer.WriteInt32(height);
writer.WriteInt32(width);
writer.WriteInt32(pixel_width);
writer.WriteInt32(pixel_height);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_WINDOW_SIZE, writer.ToByteArray());
Transmit(p);
}
private void SendRequestPTY()
{
SSH1DataWriter writer = new SSH1DataWriter();
writer.WriteString(_param.TerminalName);
writer.WriteInt32(_param.TerminalHeight);
writer.WriteInt32(_param.TerminalWidth);
writer.WriteInt32(_param.TerminalPixelWidth);
writer.WriteInt32(_param.TerminalPixelHeight);
writer.Write(new byte[1]); //TTY_OP_END
SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_REQUEST_PTY, writer.ToByteArray());
SSH1Packet.WriteTo(_stream, _tCipher);
TraceTransmissionEvent(PacketType.SSH_CMSG_REQUEST_PTY, "open shell: terminal={0} width={1} height={2}", _param.TerminalName, _param.TerminalWidth, _param.TerminalHeight);
}
public override void ListenForwardedPort(string allowed_host, int bind_port)
{
SSH1DataWriter writer = new SSH1DataWriter();
writer.WriteInt32(bind_port);
writer.WriteString(allowed_host);
writer.WriteInt32(0);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_PORT_FORWARD_REQUEST, writer.ToByteArray());
p.WriteTo(_stream, _tCipher);
TraceTransmissionEvent(PacketType.SSH_CMSG_PORT_FORWARD_REQUEST, "start to listening to remote port: host={0} port={1}", allowed_host, bind_port);
if (_shellID == -1)
{
ExecShell();
_shellID = _channel_collection.RegisterChannelEventReceiver(null, new SSH1DummyReceiver()).LocalID;
}
}
public override SSHChannel ForwardPort(ISSHChannelEventReceiver receiver, string remote_host, int remote_port, string originator_host, int originator_port)
{
if (_shellID == -1)
{
ExecShell();
_shellID = _channel_collection.RegisterChannelEventReceiver(null, new SSH1DummyReceiver()).LocalID;
}
int local_id = _channel_collection.RegisterChannelEventReceiver(null, receiver).LocalID;
SSH1DataWriter writer = new SSH1DataWriter();
writer.WriteInt32(local_id); //channel id is fixed to 0
writer.WriteString(remote_host);
writer.WriteInt32(remote_port);
//originator is specified only if SSH_PROTOFLAG_HOST_IN_FWD_OPEN is specified
//writer.Write(originator_host);
SSH1Packet SSH1Packet = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_PORT_OPEN, writer.ToByteArray());
SSH1Packet.WriteTo(_stream, _tCipher);
TraceTransmissionEvent(PacketType.SSH_MSG_PORT_OPEN, "open forwarded port: host={0} port={1}", remote_host, remote_port);
return(new SSH1Channel(this, ChannelType.ForwardedLocalToRemote, local_id));
}
/**
* transmits channel data
*/
public override void Transmit(byte[] data, int offset, int length)
{
SSH1DataWriter wr = new SSH1DataWriter();
if (_type == ChannelType.Shell)
{
wr.WriteAsString(data, offset, length);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_STDIN_DATA, wr.ToByteArray());
Transmit(p);
}
else
{
wr.WriteInt32(_remoteID);
wr.WriteAsString(data, offset, length);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_DATA, wr.ToByteArray());
Transmit(p);
}
}
/**
* closes this channel
*/
public override void Close()
{
if (!_connection.IsOpen)
{
return;
}
if (_type == ChannelType.Shell)
{
SSH1DataWriter wr2 = new SSH1DataWriter();
wr2.WriteInt32(_remoteID);
SSH1Packet p2 = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_EOF, wr2.ToByteArray());
Transmit(p2);
}
SSH1DataWriter wr = new SSH1DataWriter();
wr.WriteInt32(_remoteID);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_CLOSE, wr.ToByteArray());
Transmit(p);
}
private void SendSessionKey(byte[] session_key)
{
try {
//step1 XOR with session_id
byte[] working_data = new byte[session_key.Length];
byte[] session_id = CalcSessionID();
Array.Copy(session_key, 0, working_data, 0, session_key.Length);
for (int i = 0; i < session_id.Length; i++)
{
working_data[i] ^= session_id[i];
}
//step2 decrypts with RSA
RSAPublicKey first_encryption;
RSAPublicKey second_encryption;
SSHServerInfo si = _cInfo._serverinfo;
int first_key_bytelen, second_key_bytelen;
if (si.server_key_bits < si.host_key_bits)
{
first_encryption = new RSAPublicKey(si.server_key_public_exponent, si.server_key_public_modulus);
second_encryption = new RSAPublicKey(si.host_key_public_exponent, si.host_key_public_modulus);
first_key_bytelen = (si.server_key_bits + 7) / 8;
second_key_bytelen = (si.host_key_bits + 7) / 8;
}
else
{
first_encryption = new RSAPublicKey(si.host_key_public_exponent, si.host_key_public_modulus);
second_encryption = new RSAPublicKey(si.server_key_public_exponent, si.server_key_public_modulus);
first_key_bytelen = (si.host_key_bits + 7) / 8;
second_key_bytelen = (si.server_key_bits + 7) / 8;
}
Rng rng = RngManager.GetSecureRng();
BigInteger first_result = RSAUtil.PKCS1PadType2(new BigInteger(working_data), first_key_bytelen, rng).modPow(first_encryption.Exponent, first_encryption.Modulus);
BigInteger second_result = RSAUtil.PKCS1PadType2(first_result, second_key_bytelen, rng).modPow(second_encryption.Exponent, second_encryption.Modulus);
//output
SSH1DataWriter writer = new SSH1DataWriter();
writer.WriteByte((byte)_cInfo._algorithmForTransmittion);
writer.Write(si.anti_spoofing_cookie);
writer.WriteBigInteger(second_result);
writer.WriteInt32(0); //protocol flags
//send
TraceTransmissionEvent(PacketType.SSH_CMSG_SESSION_KEY, "sent encrypted session-keys");
SSH1Packet packet = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_SESSION_KEY, writer.ToByteArray());
packet.WriteTo(_stream);
_sessionID = session_id;
}
catch (Exception e) {
if (e is IOException)
{
throw (IOException)e;
}
else
{
string t = e.StackTrace;
throw new SSHException(e.Message); //IOException以外はみなSSHExceptionにしてしまう
}
}
}
