public async Task AuthenticateAsync_ValidClientRootAuthorityCertificateWithSubDomain_ReturnsAuthority()
{
// Arrange
var clientIdentity = Identity.Parse("*****@*****.**");
var clientCertificate = CertificateUtil.CreateSelfSignedCertificate(
$"*.{clientIdentity.Domain.TrimFirstDomainLabel()}");
var clientTransport = new TcpTransport(
_envelopeSerializer.Object,
clientCertificate,
serverCertificateValidationCallback:
(sender, certificate, chain, sslPolicyErrors) => true);
await clientTransport.OpenAsync(_serverUri, _cancellationToken);
var serverTransport = await _tcpListener.AcceptTransportAsync(_cancellationToken);
await serverTransport.OpenAsync(_serverUri, _cancellationToken);
await Task.WhenAll(
serverTransport.SetEncryptionAsync(SessionEncryption.TLS, _cancellationToken),
clientTransport.SetEncryptionAsync(SessionEncryption.TLS, _cancellationToken));
// Act
var actual = await((IAuthenticatableTransport)serverTransport).AuthenticateAsync(clientIdentity);
// Assert
actual.ShouldBe(DomainRole.Authority);
}
public async Task AuthenticateAsync_ValidClientRootAuthorityCertificateWithSubdomain_ReturnsAuthority()
{
// Arrange
var clientIdentity = Identity.Parse("*****@*****.**");
var clientCertificate = GetWildcardDomainCertificate(clientIdentity);
var clientTransport = new TcpTransport(
_envelopeSerializer.Object,
clientCertificate,
serverCertificateValidationCallback:
(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) =>
{
return(true);
});
await clientTransport.OpenAsync(_serverUri, _cancellationToken);
var serverTransport = await _tcpListener.AcceptTransportAsync(_cancellationToken);
await serverTransport.OpenAsync(_serverUri, _cancellationToken);
await Task.WhenAll(
serverTransport.SetEncryptionAsync(SessionEncryption.TLS, _cancellationToken),
clientTransport.SetEncryptionAsync(SessionEncryption.TLS, _cancellationToken));
// Act
var actual = await((IAuthenticatableTransport)serverTransport).AuthenticateAsync(clientIdentity);
// Assert
actual.ShouldBe(DomainRole.Authority);
}
public async Task AuthenticateAsync_OtherDomainCertificate_ReturnsUnknown()
{
// Arrange
var clientIdentity = new Identity("client", "fakedomain.local");
var clientCertificate = CertificateUtil.CreateSelfSignedCertificate(clientIdentity.Domain);
var clientTransport = new TcpTransport(
_envelopeSerializer.Object,
clientCertificate,
serverCertificateValidationCallback:
(sender, certificate, chain, sslPolicyErrors) =>
{
return(true);
});
await clientTransport.OpenAsync(_serverUri, _cancellationToken);
var serverTransport = await _tcpListener.AcceptTransportAsync(_cancellationToken);
await serverTransport.OpenAsync(_serverUri, _cancellationToken);
await Task.WhenAll(
serverTransport.SetEncryptionAsync(SessionEncryption.TLS, _cancellationToken),
clientTransport.SetEncryptionAsync(SessionEncryption.TLS, _cancellationToken));
var otherClientIdentity = Identity.Parse("*****@*****.**");
// Act
var actual = await((IAuthenticatableTransport)serverTransport).AuthenticateAsync(otherClientIdentity);
// Assert
actual.ShouldBe(DomainRole.Unknown);
}
public override async Task OnConnectedAsync(ConnectionContext connection)
{
var tcpClient = new TcpClientAdapter(connection);
if (!_portEndPoints.TryGetValue(((IPEndPoint)connection.LocalEndPoint).Port, out var transportEndPoint))
{
// This should never occur, but handling anyway.
await connection.DisposeAsync();
return;
}
using var transport = new TcpTransport(tcpClient, _envelopeSerializer, transportEndPoint.ServerCertificate);
await transport.OpenAsync(null, default);
try
{
await _listener.ListenAsync(transport, connection.ConnectionClosed);
}
finally
{
if (transport.IsConnected)
{
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
await transport.CloseAsync(cts.Token);
}
}
}
private static async Task <IClientChannel> ConnectAsync()
{
var transport = new TcpTransport();
await transport.OpenAsync(
new Uri ("net.tcp://iris.limeprotocol.org:55321"),
CancellationToken.None);
var channel = new ClientChannel(
transport,
TimeSpan.FromSeconds(60));
return(channel);
}
public async Task SetupAsync()
{
_uri = new Uri("net.tcp://localhost:55321");
_cancellationToken = TimeSpan.FromSeconds(30).ToCancellationToken();
_envelopeSerializer = new FakeEnvelopeSerializer(10);
_tcpTransportListener = new TcpTransportListener(_uri, null, _envelopeSerializer);
await _tcpTransportListener.StartAsync(_cancellationToken);
var serverTcpTransportTask = _tcpTransportListener.AcceptTransportAsync(_cancellationToken);
_clientTcpTransport = new TcpTransport(_envelopeSerializer);
await _clientTcpTransport.OpenAsync(_uri, _cancellationToken);
_serverTcpTransport = (TcpTransport)await serverTcpTransportTask;
await _serverTcpTransport.OpenAsync(_uri, _cancellationToken);
}
private async Task OpenTransportAsync()
{
await ExecuteAsync(async() =>
{
AddStatusMessage("Connecting...");
var timeoutCancellationToken = _operationTimeout.ToCancellationToken();
X509Certificate2 clientCertificate = null;
if (!string.IsNullOrWhiteSpace(ClientCertificateThumbprint))
{
ClientCertificateThumbprint = ClientCertificateThumbprint
.Replace(" ", "")
.Replace("", "");
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
try
{
store.Open(OpenFlags.ReadOnly);
var certificates = store.Certificates.Find(X509FindType.FindByThumbprint, ClientCertificateThumbprint, false);
if (certificates.Count > 0)
{
clientCertificate = certificates[0];
var identity = clientCertificate.GetIdentity();
if (identity != null)
{
var fromVariableViewModel = this.Variables.FirstOrDefault(v => v.Name.Equals("from", StringComparison.OrdinalIgnoreCase));
if (fromVariableViewModel == null)
{
fromVariableViewModel = new VariableViewModel()
{
Name = "from"
};
this.Variables.Add(fromVariableViewModel);
}
fromVariableViewModel.Value = identity.ToString();
}
}
else
{
AddStatusMessage("The specified certificate was not found", true);
}
}
finally
{
store.Close();
}
}
TcpClient = new TcpClientAdapter(new TcpClient());
Transport = new TcpTransport(
TcpClient,
new EnvelopeSerializer(),
_hostUri.Host,
clientCertificate: clientCertificate,
traceWriter: this);
await Transport.OpenAsync(_hostUri, timeoutCancellationToken);
_connectionCts = new CancellationTokenSource();
var dispatcher = Dispatcher.CurrentDispatcher;
_receiveTask = ReceiveAsync(
Transport,
(e) => ReceiveEnvelopeAsync(e, dispatcher),
_connectionCts.Token)
.ContinueWith(t =>
{
IsConnected = false;
if (t.Exception != null)
{
AddStatusMessage(string.Format("Disconnected with errors: {0}", t.Exception.InnerException.Message.RemoveCrLf()), true);
}
else
{
AddStatusMessage("Disconnected");
}
}, TaskScheduler.FromCurrentSynchronizationContext());
IsConnected = true;
CanSendAsRaw = true;
AddStatusMessage("Connected");
});
}
public async Task LoginAsync()
{
IClientChannel client = null;
ITraceWriter traceWriter = null;
if (ShowTraceWindow)
{
traceWriter = Owner.TraceViewModel;
base.MessengerInstance.Send <OpenWindowMessage>(
new OpenWindowMessage()
{
WindowName = "Trace",
DataContext = Owner.TraceViewModel
});
}
IsBusy = true;
this.ErrorMessage = string.Empty;
try
{
var cancellationToken = _loginTimeout.ToCancellationToken();
var transport = new TcpTransport(traceWriter: traceWriter);
await transport.OpenAsync(_serverAddressUri, cancellationToken);
client = new ClientChannel(
transport,
_sendTimeout,
fillEnvelopeRecipients: true,
autoReplyPings: true,
autoNotifyReceipt: true);
if (RegisterUser)
{
var guestSessionResult = await client.EstablishSessionAsync(
compressionOptions => compressionOptions.First(),
encryptionOptions => SessionEncryption.TLS,
new Identity()
{
Name = Guid.NewGuid().ToString(), Domain = _userNameNode.Domain
},
(schemeOptions, roundtrip) => new GuestAuthentication(),
null,
cancellationToken
);
if (guestSessionResult.State == SessionState.Established)
{
// Creates the account
var account = new Account()
{
Password = this.Password.ToBase64()
};
await client.SetResourceAsync <Account>(
LimeUri.Parse(UriTemplates.ACCOUNT),
account,
_userNameNode,
cancellationToken);
await client.SendFinishingSessionAsync();
await client.ReceiveFinishedSessionAsync(cancellationToken);
client.DisposeIfDisposable();
transport = new TcpTransport(traceWriter: traceWriter);
await transport.OpenAsync(_serverAddressUri, cancellationToken);
client = new ClientChannel(
transport,
_sendTimeout,
fillEnvelopeRecipients: true,
autoReplyPings: true,
autoNotifyReceipt: true);
}
else if (guestSessionResult.Reason != null)
{
this.ErrorMessage = guestSessionResult.Reason.Description;
}
else
{
this.ErrorMessage = "Could not establish a guest session with the server";
}
}
var authentication = new PlainAuthentication();
authentication.SetToBase64Password(this.Password);
var sessionResult = await client.EstablishSessionAsync(
compressionOptions => compressionOptions.First(),
encryptionOptions => SessionEncryption.TLS,
new Identity()
{
Name = _userNameNode.Name, Domain = _userNameNode.Domain
},
(schemeOptions, roundtrip) => authentication,
_userNameNode.Instance,
cancellationToken);
if (sessionResult.State == SessionState.Established)
{
var rosterViewModel = new RosterViewModel(client, this);
base.Owner.ContentViewModel = rosterViewModel;
}
else if (sessionResult.Reason != null)
{
this.ErrorMessage = sessionResult.Reason.Description;
}
else
{
this.ErrorMessage = "Could not connect to the server";
}
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
client.DisposeIfDisposable();
}
finally
{
IsBusy = false;
}
}
