public override void Disconnect(string msg)
{
if (!this.IsOpen)
{
return;
}
SSH1DataWriter w = new SSH1DataWriter();
w.Write(msg);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_DISCONNECT, w.ToByteArray());
p.WriteTo(_stream, _tCipher);
base.Close();
}
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);
}
/**
* 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);
}
}
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;
}
}
//RSA authentication
private void DoRSAChallengeResponse()
{
//read key
SSH1UserAuthKey key = new SSH1UserAuthKey(_param.IdentityFile, _param.Password);
SSH1DataWriter w = new SSH1DataWriter();
w.WriteBigInteger(key.PublicModulus);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_AUTH_RSA, w.ToByteArray());
p.WriteTo(_stream, _tCipher);
TraceTransmissionEvent(PacketType.SSH_CMSG_AUTH_RSA, "RSA challenge-reponse");
DataFragment response = ReceivePacket();
SSH1DataReader reader = new SSH1DataReader(response);
PacketType pt = reader.ReadPacketType();
if (pt == PacketType.SSH_SMSG_FAILURE)
{
throw new SSHException(Strings.GetString("ServerRefusedRSA"));
}
else if (pt != PacketType.SSH_SMSG_AUTH_RSA_CHALLENGE)
{
throw new SSHException(String.Format(Strings.GetString("UnexpectedResponse"), pt));
}
TraceReceptionEvent(PacketType.SSH_SMSG_AUTH_RSA_CHALLENGE, "received challenge");
//creating challenge
BigInteger challenge = key.decryptChallenge(reader.ReadMPInt());
byte[] rawchallenge = RSAUtil.StripPKCS1Pad(challenge, 2).getBytes();
//building response
MemoryStream bos = new MemoryStream();
bos.Write(rawchallenge, 0, rawchallenge.Length); //!!mindtermでは頭が０かどうかで変なハンドリングがあった
bos.Write(_sessionID, 0, _sessionID.Length);
byte[] reply = new MD5CryptoServiceProvider().ComputeHash(bos.ToArray());
w = new SSH1DataWriter();
w.Write(reply);
p = SSH1Packet.FromPlainPayload(PacketType.SSH_CMSG_AUTH_RSA_RESPONSE, w.ToByteArray());
p.WriteTo(_stream, _tCipher);
TraceReceptionEvent(PacketType.SSH_CMSG_AUTH_RSA_RESPONSE, "received response");
}
/**
* 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);
}
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));
}
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にしてしまう
}
}
}