public Task <ITunnel> CreateTunnelAsync(TunnelDestination tunnelEndpoint)
{
using (TraceSources.IapDesktop.TraceMethod().WithParameters(tunnelEndpoint))
{
var iapEndpoint = new IapTunnelingEndpoint(
this.authorizationService.Authorization.Credential,
tunnelEndpoint.Instance,
tunnelEndpoint.RemotePort,
IapTunnelingEndpoint.DefaultNetworkInterface,
Globals.UserAgent);
// Start listener to enable clients to connect. Do not await
// the listener as we want to continue listeining in the
// background.
var listener = SshRelayListener.CreateLocalListener(iapEndpoint);
var cts = new CancellationTokenSource();
_ = listener.ListenAsync(cts.Token);
// Return the tunnel which allows the listener to be stopped
// via the CancellationTokenSource.
return(Task.FromResult <ITunnel>(new Tunnel(iapEndpoint, listener, cts)));
}
}
public Tunnel(
IapTunnelingEndpoint endpoint,
SshRelayListener listener,
CancellationTokenSource cancellationTokenSource)
{
this.Endpoint = endpoint;
this.listener = listener;
this.cancellationTokenSource = cancellationTokenSource;
}
public static RdpTunnel Create(VmInstanceReference vmRef)
{
var listener = SshRelayListener.CreateLocalListener(
new IapTunnelingEndpoint(
Defaults.GetCredential(),
vmRef,
3389,
IapTunnelingEndpoint.DefaultNetworkInterface));
var tokenSource = new CancellationTokenSource();
listener.ListenAsync(tokenSource.Token);
return(new RdpTunnel(listener, tokenSource));
}
public static RdpTunnel Create(InstanceLocator vmRef, ICredential credential)
{
var listener = SshRelayListener.CreateLocalListener(
new IapTunnelingEndpoint(
credential,
vmRef,
3389,
IapTunnelingEndpoint.DefaultNetworkInterface,
TestProject.UserAgent));
var tokenSource = new CancellationTokenSource();
listener.ListenAsync(tokenSource.Token);
return(new RdpTunnel(listener, tokenSource));
}
protected override INetworkStream ConnectToEchoServer(VmInstanceReference vmRef)
{
var listener = SshRelayListener.CreateLocalListener(
new IapTunnelingEndpoint(
Defaults.GetCredential(),
vmRef,
7,
IapTunnelingEndpoint.DefaultNetworkInterface));
listener.ClientAcceptLimit = 1; // Terminate after first connection.
listener.ListenAsync(CancellationToken.None);
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(IPAddress.Loopback, listener.LocalPort));
return(new SocketStream(socket));
}
public Task <ITunnel> CreateTunnelAsync(
TunnelDestination tunnelEndpoint,
ISshRelayPolicy relayPolicy)
{
using (ApplicationTraceSources.Default.TraceMethod().WithParameters(tunnelEndpoint))
{
var clientCertificate =
(this.authorizationService.DeviceEnrollment != null &&
this.authorizationService.DeviceEnrollment.State == DeviceEnrollmentState.Enrolled)
? this.authorizationService.DeviceEnrollment.Certificate
: null;
if (clientCertificate != null)
{
ApplicationTraceSources.Default.TraceInformation(
"Using client certificate (valid till {0})", clientCertificate.NotAfter);
}
var iapEndpoint = new IapTunnelingEndpoint(
this.authorizationService.Authorization.Credential,
tunnelEndpoint.Instance,
tunnelEndpoint.RemotePort,
IapTunnelingEndpoint.DefaultNetworkInterface,
Globals.UserAgent,
clientCertificate);
// Start listener to enable clients to connect. Do not await
// the listener as we want to continue listeining in the
// background.
var listener = SshRelayListener.CreateLocalListener(
iapEndpoint,
relayPolicy);
var cts = new CancellationTokenSource();
_ = listener.ListenAsync(cts.Token);
// Return the tunnel which allows the listener to be stopped
// via the CancellationTokenSource.
return(Task.FromResult <ITunnel>(new Tunnel(iapEndpoint, listener, cts)));
}
}
protected override INetworkStream ConnectToWebServer(
InstanceLocator vmRef,
ICredential credential)
{
var listener = SshRelayListener.CreateLocalListener(
new IapTunnelingEndpoint(
credential,
vmRef,
80,
IapTunnelingEndpoint.DefaultNetworkInterface,
TestProject.UserAgent));
listener.ClientAcceptLimit = 1; // Terminate after first connection.
listener.ListenAsync(CancellationToken.None);
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(IPAddress.Loopback, listener.LocalPort));
return(new SocketStream(socket));
}
public async Task WhenSendingMessagesToEchoServer_ThenStatisticsAreUpdated(
[LinuxInstance(InitializeScript = InitializeScripts.InstallEchoServer)] ResourceTask <InstanceLocator> vm,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential,
[Values(
1,
(int)DataMessage.MaxDataLength,
(int)DataMessage.MaxDataLength * 2)] int length)
{
var message = new byte[length];
FillArray(message);
var locator = await vm;
var listener = SshRelayListener.CreateLocalListener(
new IapTunnelingEndpoint(
await credential,
await vm,
7,
IapTunnelingEndpoint.DefaultNetworkInterface,
TestProject.UserAgent),
new AllowAllRelayPolicy());
listener.ClientAcceptLimit = 1; // Terminate after first connection.
listener.ListenAsync(CancellationToken.None).ContinueWith(_ => { });
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(IPAddress.Loopback, listener.LocalPort));
var clientStreamStats = new ConnectionStatistics();
var clientStream = new SocketStream(socket, clientStreamStats);
using (var tokenSource = new CancellationTokenSource())
{
// Write full payload.
await clientStream.WriteAsync(message, 0, message.Length, tokenSource.Token);
Assert.AreEqual(length, clientStreamStats.BytesTransmitted);
// Read entire response.
var response = new byte[length];
int totalBytesRead = 0;
while (true)
{
var bytesRead = await clientStream.ReadAsync(
response,
totalBytesRead,
response.Length - totalBytesRead,
tokenSource.Token);
totalBytesRead += bytesRead;
if (bytesRead == 0 || totalBytesRead >= length)
{
break;
}
}
await clientStream.CloseAsync(tokenSource.Token);
await Task.Delay(50);
Assert.AreEqual(length, totalBytesRead, "bytes read");
Assert.AreEqual(length, clientStreamStats.BytesReceived, "client received");
Assert.AreEqual(length, listener.Statistics.BytesReceived, "server received");
Assert.AreEqual(length, listener.Statistics.BytesTransmitted, "server sent");
}
}
private IapTunnel(SshRelayListener listener, CancellationTokenSource tokenSource)
{
this.listener = listener;
this.tokenSource = tokenSource;
}
