private void ReceiveServerKeys()
{
DataFragment packet = ReceivePacket();
SSH1DataReader reader = new SSH1DataReader(packet);
PacketType pt = reader.ReadPacketType();
if (pt != PacketType.SSH_SMSG_PUBLIC_KEY)
throw new SSHException("unexpected SSH SSH1Packet type " + pt, reader.ReadAll());
_cInfo._serverinfo = new SSHServerInfo(reader);
_cInfo._hostkey = new RSAPublicKey(_cInfo._serverinfo.host_key_public_exponent, _cInfo._serverinfo.host_key_public_modulus);
//read protocol support parameters
int protocol_flags = reader.ReadInt32();
int supported_ciphers_mask = reader.ReadInt32();
_cInfo.SetSupportedCipherAlgorithms(supported_ciphers_mask);
int supported_authentications_mask = reader.ReadInt32();
//Debug.WriteLine(String.Format("ServerOptions {0} {1} {2}", protocol_flags, supported_ciphers_mask, supported_authentications_mask));
if (reader.Rest > 0)
throw new SSHException("data length mismatch", reader.ReadAll());
bool found = false;
foreach (CipherAlgorithm a in _param.PreferableCipherAlgorithms) {
if (a != CipherAlgorithm.Blowfish && a != CipherAlgorithm.TripleDES)
continue;
else if (a == CipherAlgorithm.Blowfish && (supported_ciphers_mask & (1 << (int)CipherAlgorithm.Blowfish)) == 0)
continue;
else if (a == CipherAlgorithm.TripleDES && (supported_ciphers_mask & (1 << (int)CipherAlgorithm.TripleDES)) == 0)
continue;
_cInfo._algorithmForReception = _cInfo._algorithmForTransmittion = a;
found = true;
break;
}
if (!found)
throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedX"), "Blowfish/TripleDES"));
if (_param.AuthenticationType == AuthenticationType.Password && (supported_authentications_mask & (1 << (int)AuthenticationType.Password)) == 0)
throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedPassword")), reader.ReadAll());
if (_param.AuthenticationType == AuthenticationType.PublicKey && (supported_authentications_mask & (1 << (int)AuthenticationType.PublicKey)) == 0)
throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedRSA")), reader.ReadAll());
TraceReceptionEvent(pt, "received server key");
}
private DataFragment ReceivePacket()
{
while (true) {
DataFragment data = _packetReceiver.WaitResponse();
PacketType pt = (PacketType)data.ByteAt(0); //shortcut
if (pt == PacketType.SSH_MSG_IGNORE) {
SSH1DataReader r = new SSH1DataReader(data);
r.ReadPacketType();
if (_eventReceiver != null)
_eventReceiver.OnIgnoreMessage(r.ReadString());
}
else if (pt == PacketType.SSH_MSG_DEBUG) {
SSH1DataReader r = new SSH1DataReader(data);
r.ReadPacketType();
if (_eventReceiver != null)
_eventReceiver.OnDebugMessage(false, r.ReadString());
}
else
return data;
}
}
//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");
}
private bool ReceiveAuthenticationResult()
{
DataFragment packet = ReceivePacket();
SSH1DataReader r = new SSH1DataReader(packet);
PacketType type = r.ReadPacketType();
TraceReceptionEvent(type, "user authentication response");
if (type == PacketType.SSH_MSG_DEBUG) {
//Debug.WriteLine("receivedd debug message:"+Encoding.ASCII.GetString(r.ReadString()));
return ReceiveAuthenticationResult();
}
else if (type == PacketType.SSH_SMSG_SUCCESS)
return true;
else if (type == PacketType.SSH_SMSG_FAILURE)
return false;
else
throw new SSHException("unexpected type: " + type);
}
internal void AsyncReceivePacket(DataFragment data)
{
try {
int len = 0, channel = 0;
SSH1DataReader re = new SSH1DataReader(data);
PacketType pt = re.ReadPacketType();
switch (pt) {
case PacketType.SSH_SMSG_STDOUT_DATA:
len = re.ReadInt32();
_channel_collection.FindChannelEntry(_shellID).Receiver.OnData(re.Image, re.Offset, len);
break;
case PacketType.SSH_SMSG_STDERR_DATA: {
_channel_collection.FindChannelEntry(_shellID).Receiver.OnExtendedData((int)PacketType.SSH_SMSG_STDERR_DATA, re.ReadString());
}
break;
case PacketType.SSH_MSG_CHANNEL_DATA:
channel = re.ReadInt32();
len = re.ReadInt32();
_channel_collection.FindChannelEntry(channel).Receiver.OnData(re.Image, re.Offset, len);
break;
case PacketType.SSH_MSG_PORT_OPEN:
ProcessPortforwardingRequest(_eventReceiver, re);
break;
case PacketType.SSH_MSG_CHANNEL_CLOSE: {
channel = re.ReadInt32();
ISSHChannelEventReceiver r = _channel_collection.FindChannelEntry(channel).Receiver;
_channel_collection.UnregisterChannelEventReceiver(channel);
r.OnChannelClosed();
}
break;
case PacketType.SSH_MSG_CHANNEL_CLOSE_CONFIRMATION:
channel = re.ReadInt32();
break;
case PacketType.SSH_MSG_DISCONNECT:
_eventReceiver.OnConnectionClosed();
break;
case PacketType.SSH_SMSG_EXITSTATUS:
_channel_collection.FindChannelEntry(_shellID).Receiver.OnChannelClosed();
break;
case PacketType.SSH_MSG_DEBUG:
_eventReceiver.OnDebugMessage(false, re.ReadString());
break;
case PacketType.SSH_MSG_IGNORE:
_eventReceiver.OnIgnoreMessage(re.ReadString());
break;
case PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION: {
int local = re.ReadInt32();
int remote = re.ReadInt32();
_channel_collection.FindChannelEntry(local).Receiver.OnChannelReady();
}
break;
case PacketType.SSH_SMSG_SUCCESS:
if (_executingShell) {
ExecShell();
_channel_collection.FindChannelEntry(_shellID).Receiver.OnChannelReady();
_executingShell = false;
}
break;
default:
_eventReceiver.OnUnknownMessage((byte)pt, re.ReadAll());
break;
}
}
catch (Exception ex) {
_eventReceiver.OnError(ex);
}
}
