public SSH2DataReader(DataFragment data) : base(data)
{
}
public SSH2DataReader(DataFragment data)
: base(data)
{
}
private void SelectedAddressInspector_DataChanged(DataFragment data)
{
this.hexView.ApplyEdit(data);
this.selectedAddressInspector.Target = this.hexView.GetSelectedData();
}
public void OnData(DataFragment data)
{
_connection.AsyncReceivePacket(data);
}
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);
}
}
private PacketType SneakPacketType(DataFragment data)
{
return((PacketType)data.ByteAt(0));
}
public override int Read(byte[] buffer, int offset, int count)
{
int totalRead = 0;
// Determine fragment
while (count > 0 && _position < _length)
{
long fragmentOffset;
DataFragment fragment = FindFragment(_position, out fragmentOffset);
long diskOffset = fragment.LCN * _bytesPrCluster;
long fragmentLength = fragment.Clusters * _bytesPrCluster;
int actualRead;
if (fragment.IsCompressed)
{
// Read and decompress
byte[] compressedData = new byte[fragmentLength];
_diskStream.Seek(diskOffset, SeekOrigin.Begin);
_diskStream.Read(compressedData, 0, compressedData.Length);
int decompressedLength = (int)((fragment.Clusters + fragment.CompressedClusters) * _bytesPrCluster);
int toRead = (int)Math.Min(decompressedLength - fragmentOffset, Math.Min(_length - _position, count));
// Debug.Assert(decompressedLength == _compressionClusterCount * _bytesPrCluster);
if (fragmentOffset == 0 && toRead == decompressedLength)
{
// Decompress directly (we're in the middle of a file and reading a full 16 clusters out)
actualRead = _compressor.Decompress(compressedData, 0, compressedData.Length, buffer, offset);
}
else
{
// Decompress temporarily
byte[] tmp = new byte[decompressedLength];
int decompressed = _compressor.Decompress(compressedData, 0, compressedData.Length, tmp, 0);
toRead = Math.Min(toRead, decompressed);
// Copy wanted data
Array.Copy(tmp, fragmentOffset, buffer, offset, toRead);
actualRead = toRead;
}
}
else if (fragment.IsSparseFragment)
{
// Fill with zeroes
// How much to fill?
int toFill = (int)Math.Min(fragmentLength - fragmentOffset, count);
Array.Clear(buffer, offset, toFill);
actualRead = toFill;
}
else
{
// Read directly
// How much can we read?
int toRead = (int)Math.Min(fragmentLength - fragmentOffset, Math.Min(_length - _position, count));
// Read it
_diskStream.Seek(diskOffset + fragmentOffset, SeekOrigin.Begin);
actualRead = _diskStream.Read(buffer, offset, toRead);
}
// Increments
count -= actualRead;
offset += actualRead;
_position += actualRead;
totalRead += actualRead;
// Check
if (actualRead == 0)
{
break;
}
}
return(totalRead);
}
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");
}
public void Send(DataFragment data)
{
}
public void OnUnhandledPacket(byte packetType, DataFragment data)
{
}
public void OnExtendedData(uint type, DataFragment data)
{
}
public void OnEstablished(DataFragment data)
{
}
// for debug
private void Dump(string caption, DataFragment data)
{
Dump(caption, data.Data, data.Offset, data.Length);
}
