public async Task SslStream_StreamToStream_EOFDuringFrameRead_ThrowsIOException()
{
var network = new VirtualNetwork();
using (var clientNetworkStream = new VirtualNetworkStream(network, isServer: false))
using (var serverNetworkStream = new VirtualNetworkStream(network, isServer: true))
{
int readMode = 0;
var serverWrappedNetworkStream = new DelegateStream(
canWriteFunc: () => true,
canReadFunc: () => true,
writeFunc: (buffer, offset, count) => serverNetworkStream.Write(buffer, offset, count),
readFunc: (buffer, offset, count) =>
{
// Do normal reads as requested until the read mode is set
// to 1. Then do a single read of only 10 bytes to read only
// part of the message, and subsequently return EOF.
if (readMode == 0)
{
return(serverNetworkStream.Read(buffer, offset, count));
}
else if (readMode == 1)
{
readMode = 2;
return(serverNetworkStream.Read(buffer, offset, 10)); // read at least header but less than full frame
}
else
{
return(0);
}
});
using (var clientSslStream = new SslStream(clientNetworkStream, false, AllowAnyServerCertificate))
using (var serverSslStream = new SslStream(serverWrappedNetworkStream))
{
await DoHandshake(clientSslStream, serverSslStream);
await clientSslStream.WriteAsync(new byte[20], 0, 20);
readMode = 1;
await Assert.ThrowsAsync <IOException>(() => serverSslStream.ReadAsync(new byte[1], 0, 1));
}
}
}
public void NegotiateStream_EchoServer_NTLM_ClientWriteRead_Successive_Async_Success()
{
if (!_isNtlmAvailable)
{
_output.WriteLine("skipping NegotiateStream_EchoServer_NTLM_ClientWriteRead_Successive_Async_Success");
return;
}
byte[] firstRecvBuffer = new byte[_firstMessage.Length];
byte[] secondRecvBuffer = new byte[_secondMessage.Length];
VirtualNetwork network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new UnixGssFakeNegotiateStream(serverStream))
{
Assert.False(client.IsAuthenticated, "client.IsAuthenticated");
Assert.False(server.IsAuthenticated, "server.IsAuthenticated");
string user = string.Format("{0}@{1}", TestConfiguration.NtlmUser, TestConfiguration.Domain);
NetworkCredential credential = new NetworkCredential(user, TestConfiguration.NtlmPassword);
Task[] auth = new Task[] {
client.AuthenticateAsClientAsync(credential, TestConfiguration.HostTarget),
server.AuthenticateAsServerAsync()
};
bool finished = Task.WaitAll(auth, TestConfiguration.PassingTestTimeoutMilliseconds);
Assert.True(finished, "Handshake completed in the allotted time");
//clearing message queue
byte[] junkBytes = new byte[5];
int j = clientStream.Read(junkBytes, 0, 5);
Task serverTask = server.PollMessageAsync(2);
Task[] msgTasks = new Task[] {
client.WriteAsync(_firstMessage, 0, _firstMessage.Length).ContinueWith((t) =>
client.WriteAsync(_secondMessage, 0, _secondMessage.Length)).Unwrap(),
ReadAllAsync(client, firstRecvBuffer, 0, firstRecvBuffer.Length).ContinueWith((t) =>
ReadAllAsync(client, secondRecvBuffer, 0, secondRecvBuffer.Length)).Unwrap(),
serverTask
};
finished = Task.WaitAll(msgTasks, TestConfiguration.PassingTestTimeoutMilliseconds);
Assert.True(finished, "Messages sent and received in the allotted time");
Assert.True(_firstMessage.SequenceEqual(firstRecvBuffer), "The first message received is as expected");
Assert.True(_secondMessage.SequenceEqual(secondRecvBuffer), "The second message received is as expected");
}
}
public async Task NegotiateStream_EchoServer_NTLM_ClientWriteRead_Successive_Sync_Success()
{
if (!_isNtlmAvailable)
{
_output.WriteLine("skipping NegotiateStream_EchoServer_NTLM_ClientWriteRead_Successive_Sync_Success");
return;
}
byte[] firstRecvBuffer = new byte[_firstMessage.Length];
byte[] secondRecvBuffer = new byte[_secondMessage.Length];
VirtualNetwork network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new UnixGssFakeNegotiateStream(serverStream))
{
Assert.False(client.IsAuthenticated, "client.IsAuthenticated");
Assert.False(server.IsAuthenticated, "server.IsAuthenticated");
string user = string.Format("{0}@{1}", TestConfiguration.NtlmUser, TestConfiguration.Domain);
NetworkCredential credential = new NetworkCredential(user, TestConfiguration.NtlmPassword);
Task[] auth = new Task[] {
client.AuthenticateAsClientAsync(credential, TestConfiguration.HostTarget),
server.AuthenticateAsServerAsync()
};
await TestConfiguration.WhenAllOrAnyFailedWithTimeout(auth);
//clearing message queue
byte[] junkBytes = new byte[5];
int j = clientStream.Read(junkBytes, 0, 5);
Task svrMsgTask = server.PollMessageAsync(2);
client.Write(_firstMessage, 0, _firstMessage.Length);
client.Write(_secondMessage, 0, _secondMessage.Length);
client.Read(firstRecvBuffer, 0, firstRecvBuffer.Length);
client.Read(secondRecvBuffer, 0, secondRecvBuffer.Length);
Assert.True(_firstMessage.SequenceEqual(firstRecvBuffer), "first message received is as expected");
Assert.True(_secondMessage.SequenceEqual(secondRecvBuffer), "second message received is as expected");
await svrMsgTask.TimeoutAfter(TestConfiguration.PassingTestTimeoutMilliseconds);
}
}
