public void ToString_CommentsIsNull()
{
var sshIdentification = new SshIdentification("2.0", "SSH.NET_2020.0.0");
Assert.AreEqual("SSH-2.0-SSH.NET_2020.0.0", sshIdentification.ToString());
sshIdentification = new SshIdentification("2.0", "SSH.NET_2020.0.0", null);
Assert.AreEqual("SSH-2.0-SSH.NET_2020.0.0", sshIdentification.ToString());
}
public void Ctor_ProtocolVersionAndSoftwareVersion()
{
const string protocolVersion = "1.5";
const string softwareVersion = "SSH.NET_2020.0.0";
var sshIdentification = new SshIdentification(protocolVersion, softwareVersion);
Assert.AreSame(protocolVersion, sshIdentification.ProtocolVersion);
Assert.AreSame(softwareVersion, sshIdentification.SoftwareVersion);
Assert.IsNull(sshIdentification.Comments);
}
public void Ctor_ProtocolVersionAndSoftwareVersionAndComments()
{
const string protocolVersion = "1.5";
const string softwareVersion = "SSH.NET_2020.0.0";
const string comments = "Beware, dangerous!";
var sshIdentification = new SshIdentification(protocolVersion, softwareVersion, comments);
Assert.AreSame(protocolVersion, sshIdentification.ProtocolVersion);
Assert.AreSame(softwareVersion, sshIdentification.SoftwareVersion);
Assert.AreSame(comments, sshIdentification.Comments);
}
private IPacket PrivateReadPacket()
{
IPacket p = null;
switch (SocketModeRx)
{
case Mode.Ascii:
{
p = new SshIdentification(pr.ReadLine().ToByteArray());
break;
}
case Mode.PlainText:
{
ServerSequence++;
int packetLength = pr.ReadInt32();
byte paddingLength = pr.ReadByte();
var payload = pr.ReadBytes(packetLength - paddingLength - 1);
pr.ReadBytes(paddingLength);
p = PacketFactory.Create(session, payload);
break;
}
case Mode.CipherText:
{
if (Decryptor == null)
{
session.KexProcessor.Wait();
}
int packetLength = pr.ReadInt32();
byte paddingLength = pr.ReadByte();
var payload = pr.ReadBytes(packetLength - paddingLength - 1);
var padding = pr.ReadBytes(paddingLength);
var hmac = DecryptorMac;
hmac.WriteUInt32(ServerSequence++);
hmac.WriteInt32(packetLength);
hmac.Write(paddingLength);
hmac.Write(payload);
hmac.Write(padding);
if (rxCompressionEnabled || (rxCompressionEnabled = IsRxCompressionEnabled()))
{
if (RxZlibTransform == null)
{
RxZlibTransform = new ZlibTransform(CompressionMode.Decompress);
}
var length = RxZlibTransform.TransformBlock(payload, 0, payload.Length, zlibRxBuffer, 0);
Debug.WriteLine(string.Format("Compression In: In: {0}; Out: {1}; TotalIn: {2}; TotalOut: {3}; TotalRatio: {4}",
payload.Length, length, RxZlibTransform.TotalIn, RxZlibTransform.TotalOut, RxZlibTransform.Ratio));
payload = new byte[length];
Buffer.BlockCopy(zlibRxBuffer, 0, payload, 0, length);
}
// mac isn't encrypted, read directly from network stream
byte[] mac = new byte[hmac.BlockSize];
st.Read(mac, 0, hmac.BlockSize);
if (!hmac.IsMatch(mac))
{
throw new CryptographicException("MAC couldn't be verified!");
}
hmac.Reset();
p = PacketFactory.Create(session, payload);
break;
}
}
if (p.Code == MessageCode.SSH_MSG_IDENTIFICATION)
{
SocketModeRx = Mode.PlainText;
}
if (p.Code == MessageCode.SSH_MSG_NEWKEYS)
{
SocketModeRx = Mode.CipherText;
}
return(p);
}
protected virtual void SetupData()
{
Random = new Random();
_serverEndPoint = new IPEndPoint(IPAddress.Loopback, 8122);
ConnectionInfo = new ConnectionInfo(
_serverEndPoint.Address.ToString(),
_serverEndPoint.Port,
"user",
new PasswordAuthenticationMethod("user", "password"))
{
Timeout = TimeSpan.FromSeconds(20)
};
_keyExchangeAlgorithm = Random.Next().ToString(CultureInfo.InvariantCulture);
SessionId = new byte[10];
Random.NextBytes(SessionId);
DisconnectedRegister = new List <EventArgs>();
DisconnectReceivedRegister = new List <MessageEventArgs <DisconnectMessage> >();
ErrorOccurredRegister = new List <ExceptionEventArgs>();
ServerBytesReceivedRegister = new List <byte[]>();
ServerIdentification = new SshIdentification("2.0", "OurServerStub");
_authenticationStarted = false;
_disconnectMessage = new DisconnectMessage(DisconnectReason.ServiceNotAvailable, "Not today!");
_socketFactory = new SocketFactory();
Session = new Session(ConnectionInfo, _serviceFactoryMock.Object, _socketFactoryMock.Object);
Session.Disconnected += (sender, args) => DisconnectedRegister.Add(args);
Session.DisconnectReceived += (sender, args) => DisconnectReceivedRegister.Add(args);
Session.ErrorOccured += (sender, args) => ErrorOccurredRegister.Add(args);
Session.KeyExchangeInitReceived += (sender, args) =>
{
var newKeysMessage = new NewKeysMessage();
var newKeys = newKeysMessage.GetPacket(8, null);
ServerSocket.Send(newKeys, 4, newKeys.Length - 4, SocketFlags.None);
};
ServerListener = new AsyncSocketListener(_serverEndPoint);
ServerListener.Connected += socket =>
{
ServerSocket = socket;
// Since we're mocking the protocol version exchange, we'll immediately stat KEX upon
// having established the connection instead of when the client has been identified
var keyExchangeInitMessage = new KeyExchangeInitMessage
{
CompressionAlgorithmsClientToServer = new string[0],
CompressionAlgorithmsServerToClient = new string[0],
EncryptionAlgorithmsClientToServer = new string[0],
EncryptionAlgorithmsServerToClient = new string[0],
KeyExchangeAlgorithms = new[] { _keyExchangeAlgorithm },
LanguagesClientToServer = new string[0],
LanguagesServerToClient = new string[0],
MacAlgorithmsClientToServer = new string[0],
MacAlgorithmsServerToClient = new string[0],
ServerHostKeyAlgorithms = new string[0]
};
var keyExchangeInit = keyExchangeInitMessage.GetPacket(8, null);
ServerSocket.Send(keyExchangeInit, 4, keyExchangeInit.Length - 4, SocketFlags.None);
};
ServerListener.BytesReceived += (received, socket) =>
{
ServerBytesReceivedRegister.Add(received);
if (!_authenticationStarted)
{
var serviceAcceptMessage = ServiceAcceptMessageBuilder.Create(ServiceName.UserAuthentication).Build();
ServerSocket.Send(serviceAcceptMessage, 0, serviceAcceptMessage.Length, SocketFlags.None);
_authenticationStarted = true;
}
};
ServerListener.Start();
ClientSocket = new DirectConnector(_socketFactory).Connect(ConnectionInfo);
}
public void ToString_Comments()
{
var sshIdentification = new SshIdentification("2.0", "SSH.NET", "Beware, dangerous");
Assert.AreEqual("SSH-2.0-SSH.NET Beware, dangerous", sshIdentification.ToString());
}
protected void Act()
{
_actual = _protocolVersionExchange.Start(_clientVersion, _client, _timeout);
}
