|
| 1 | +using System; |
| 2 | +using System.Collections.Generic; |
| 3 | +using System.Globalization; |
| 4 | +using System.Net; |
| 5 | +using System.Net.Sockets; |
| 6 | +using System.Security.Cryptography; |
| 7 | +using System.Text; |
| 8 | +using Microsoft.VisualStudio.TestTools.UnitTesting; |
| 9 | +using Moq; |
| 10 | +using Renci.SshNet.Common; |
| 11 | +using Renci.SshNet.Compression; |
| 12 | +using Renci.SshNet.Messages; |
| 13 | +using Renci.SshNet.Messages.Transport; |
| 14 | +using Renci.SshNet.Security; |
| 15 | +using Renci.SshNet.Security.Cryptography; |
| 16 | +using Renci.SshNet.Tests.Common; |
| 17 | + |
| 18 | +namespace Renci.SshNet.Tests.Classes |
| 19 | +{ |
| 20 | + [TestClass] |
| 21 | + public class SessionTest_Connected_ServerAndClientDisconnectRace |
| 22 | + { |
| 23 | + private Mock<IServiceFactory> _serviceFactoryMock; |
| 24 | + private Mock<IKeyExchange> _keyExchangeMock; |
| 25 | + private Mock<IClientAuthentication> _clientAuthenticationMock; |
| 26 | + private IPEndPoint _serverEndPoint; |
| 27 | + private string _keyExchangeAlgorithm; |
| 28 | + private DisconnectMessage _disconnectMessage; |
| 29 | + |
| 30 | + protected Random Random { get; private set; } |
| 31 | + protected byte[] SessionId { get; private set; } |
| 32 | + protected ConnectionInfo ConnectionInfo { get; private set; } |
| 33 | + protected IList<EventArgs> DisconnectedRegister { get; private set; } |
| 34 | + protected IList<MessageEventArgs<DisconnectMessage>> DisconnectReceivedRegister { get; private set; } |
| 35 | + protected IList<ExceptionEventArgs> ErrorOccurredRegister { get; private set; } |
| 36 | + protected AsyncSocketListener ServerListener { get; private set; } |
| 37 | + protected IList<byte[]> ServerBytesReceivedRegister { get; private set; } |
| 38 | + protected Session Session { get; private set; } |
| 39 | + protected Socket ServerSocket { get; private set; } |
| 40 | + |
| 41 | + private void TearDown() |
| 42 | + { |
| 43 | + if (ServerListener != null) |
| 44 | + { |
| 45 | + ServerListener.Dispose(); |
| 46 | + } |
| 47 | + |
| 48 | + if (Session != null) |
| 49 | + { |
| 50 | + Session.Dispose(); |
| 51 | + } |
| 52 | + } |
| 53 | + |
| 54 | + protected virtual void SetupData() |
| 55 | + { |
| 56 | + Random = new Random(); |
| 57 | + |
| 58 | + _serverEndPoint = new IPEndPoint(IPAddress.Loopback, 8122); |
| 59 | + ConnectionInfo = new ConnectionInfo( |
| 60 | + _serverEndPoint.Address.ToString(), |
| 61 | + _serverEndPoint.Port, |
| 62 | + "user", |
| 63 | + new PasswordAuthenticationMethod("user", "password")) |
| 64 | + { Timeout = TimeSpan.FromSeconds(20) }; |
| 65 | + _keyExchangeAlgorithm = Random.Next().ToString(CultureInfo.InvariantCulture); |
| 66 | + SessionId = new byte[10]; |
| 67 | + Random.NextBytes(SessionId); |
| 68 | + DisconnectedRegister = new List<EventArgs>(); |
| 69 | + DisconnectReceivedRegister = new List<MessageEventArgs<DisconnectMessage>>(); |
| 70 | + ErrorOccurredRegister = new List<ExceptionEventArgs>(); |
| 71 | + ServerBytesReceivedRegister = new List<byte[]>(); |
| 72 | + _disconnectMessage = new DisconnectMessage(DisconnectReason.ServiceNotAvailable, "Not today!"); |
| 73 | + |
| 74 | + Session = new Session(ConnectionInfo, _serviceFactoryMock.Object); |
| 75 | + Session.Disconnected += (sender, args) => DisconnectedRegister.Add(args); |
| 76 | + Session.DisconnectReceived += (sender, args) => DisconnectReceivedRegister.Add(args); |
| 77 | + Session.ErrorOccured += (sender, args) => ErrorOccurredRegister.Add(args); |
| 78 | + Session.KeyExchangeInitReceived += (sender, args) => |
| 79 | + { |
| 80 | + var newKeysMessage = new NewKeysMessage(); |
| 81 | + var newKeys = newKeysMessage.GetPacket(8, null); |
| 82 | + ServerSocket.Send(newKeys, 4, newKeys.Length - 4, SocketFlags.None); |
| 83 | + }; |
| 84 | + |
| 85 | + ServerListener = new AsyncSocketListener(_serverEndPoint); |
| 86 | + ServerListener.Connected += socket => |
| 87 | + { |
| 88 | + ServerSocket = socket; |
| 89 | + |
| 90 | + socket.Send(Encoding.ASCII.GetBytes("\r\n")); |
| 91 | + socket.Send(Encoding.ASCII.GetBytes("WELCOME banner\r\n")); |
| 92 | + socket.Send(Encoding.ASCII.GetBytes("SSH-2.0-SshStub\r\n")); |
| 93 | + }; |
| 94 | + |
| 95 | + var counter = 0; |
| 96 | + |
| 97 | + ServerListener.BytesReceived += (received, socket) => |
| 98 | + { |
| 99 | + ServerBytesReceivedRegister.Add(received); |
| 100 | + |
| 101 | + switch (counter++) |
| 102 | + { |
| 103 | + case 0: |
| 104 | + var keyExchangeInitMessage = new KeyExchangeInitMessage |
| 105 | + { |
| 106 | + CompressionAlgorithmsClientToServer = new string[0], |
| 107 | + CompressionAlgorithmsServerToClient = new string[0], |
| 108 | + EncryptionAlgorithmsClientToServer = new string[0], |
| 109 | + EncryptionAlgorithmsServerToClient = new string[0], |
| 110 | + KeyExchangeAlgorithms = new[] { _keyExchangeAlgorithm }, |
| 111 | + LanguagesClientToServer = new string[0], |
| 112 | + LanguagesServerToClient = new string[0], |
| 113 | + MacAlgorithmsClientToServer = new string[0], |
| 114 | + MacAlgorithmsServerToClient = new string[0], |
| 115 | + ServerHostKeyAlgorithms = new string[0] |
| 116 | + }; |
| 117 | + var keyExchangeInit = keyExchangeInitMessage.GetPacket(8, null); |
| 118 | + ServerSocket.Send(keyExchangeInit, 4, keyExchangeInit.Length - 4, SocketFlags.None); |
| 119 | + break; |
| 120 | + case 1: |
| 121 | + var serviceAcceptMessage =ServiceAcceptMessageBuilder.Create(ServiceName.UserAuthentication).Build(); |
| 122 | + ServerSocket.Send(serviceAcceptMessage, 0, serviceAcceptMessage.Length, SocketFlags.None); |
| 123 | + break; |
| 124 | + } |
| 125 | + }; |
| 126 | + } |
| 127 | + |
| 128 | + private void CreateMocks() |
| 129 | + { |
| 130 | + _serviceFactoryMock = new Mock<IServiceFactory>(MockBehavior.Strict); |
| 131 | + _keyExchangeMock = new Mock<IKeyExchange>(MockBehavior.Strict); |
| 132 | + _clientAuthenticationMock = new Mock<IClientAuthentication>(MockBehavior.Strict); |
| 133 | + } |
| 134 | + |
| 135 | + private void SetupMocks() |
| 136 | + { |
| 137 | + _serviceFactoryMock.Setup( |
| 138 | + p => |
| 139 | + p.CreateKeyExchange(ConnectionInfo.KeyExchangeAlgorithms, new[] { _keyExchangeAlgorithm })).Returns(_keyExchangeMock.Object); |
| 140 | + _keyExchangeMock.Setup(p => p.Name).Returns(_keyExchangeAlgorithm); |
| 141 | + _keyExchangeMock.Setup(p => p.Start(Session, It.IsAny<KeyExchangeInitMessage>())); |
| 142 | + _keyExchangeMock.Setup(p => p.ExchangeHash).Returns(SessionId); |
| 143 | + _keyExchangeMock.Setup(p => p.CreateServerCipher()).Returns((Cipher)null); |
| 144 | + _keyExchangeMock.Setup(p => p.CreateClientCipher()).Returns((Cipher)null); |
| 145 | + _keyExchangeMock.Setup(p => p.CreateServerHash()).Returns((HashAlgorithm)null); |
| 146 | + _keyExchangeMock.Setup(p => p.CreateClientHash()).Returns((HashAlgorithm)null); |
| 147 | + _keyExchangeMock.Setup(p => p.CreateCompressor()).Returns((Compressor)null); |
| 148 | + _keyExchangeMock.Setup(p => p.CreateDecompressor()).Returns((Compressor)null); |
| 149 | + _keyExchangeMock.Setup(p => p.Dispose()); |
| 150 | + _serviceFactoryMock.Setup(p => p.CreateClientAuthentication()).Returns(_clientAuthenticationMock.Object); |
| 151 | + _clientAuthenticationMock.Setup(p => p.Authenticate(ConnectionInfo, Session)); |
| 152 | + } |
| 153 | + |
| 154 | + protected virtual void Arrange() |
| 155 | + { |
| 156 | + CreateMocks(); |
| 157 | + SetupData(); |
| 158 | + SetupMocks(); |
| 159 | + |
| 160 | + ServerListener.Start(); |
| 161 | + Session.Connect(); |
| 162 | + } |
| 163 | + |
| 164 | + [TestMethod] |
| 165 | + public void Act() |
| 166 | + { |
| 167 | + for (var i = 0; i < 50; i++) |
| 168 | + { |
| 169 | + Arrange(); |
| 170 | + try |
| 171 | + { |
| 172 | + var disconnect = _disconnectMessage.GetPacket(8, null); |
| 173 | + ServerSocket.Send(disconnect, 4, disconnect.Length - 4, SocketFlags.None); |
| 174 | + Session.Disconnect(); |
| 175 | + } |
| 176 | + finally |
| 177 | + { |
| 178 | + TearDown(); |
| 179 | + } |
| 180 | + } |
| 181 | + } |
| 182 | + |
| 183 | + private class ServiceAcceptMessageBuilder |
| 184 | + { |
| 185 | + private readonly ServiceName _serviceName; |
| 186 | + |
| 187 | + private ServiceAcceptMessageBuilder(ServiceName serviceName) |
| 188 | + { |
| 189 | + _serviceName = serviceName; |
| 190 | + } |
| 191 | + |
| 192 | + public static ServiceAcceptMessageBuilder Create(ServiceName serviceName) |
| 193 | + { |
| 194 | + return new ServiceAcceptMessageBuilder(serviceName); |
| 195 | + } |
| 196 | + |
| 197 | + public byte[] Build() |
| 198 | + { |
| 199 | + var serviceName = _serviceName.ToArray(); |
| 200 | + |
| 201 | + var sshDataStream = new SshDataStream(4 + 1 + 1 + 4 + serviceName.Length); |
| 202 | + sshDataStream.Write((uint)(sshDataStream.Capacity - 4)); // packet length |
| 203 | + sshDataStream.WriteByte(0); // padding length |
| 204 | + sshDataStream.WriteByte(ServiceAcceptMessage.MessageNumber); |
| 205 | + sshDataStream.WriteBinary(serviceName); |
| 206 | + return sshDataStream.ToArray(); |
| 207 | + } |
| 208 | + } |
| 209 | + } |
| 210 | +} |
0 commit comments