public async Task WhenSetClientConnectionEncryptionLevelSetToLow_ThenConnectionSucceeds(
[WindowsInstance(InitializeScript = @"
& reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v MinEncryptionLevel /d 1 /f | Out-Default
")] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(testInstance.InstanceReference))
{
var session = await Connect(tunnel, testInstance.InstanceReference);
AwaitEvent <RemoteDesktopConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
RemoteDesktopWindowClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <RemoteDesktopWindowClosedEvent>(e =>
{
expectedEvent = e;
});
Delay(TimeSpan.FromSeconds(5));
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
private async Task <IRemoteDesktopSession> Connect(
RdpTunnel tunnel,
InstanceLocator vmInstanceReference)
{
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
vmInstanceReference,
CreateRandomUsername(),
CancellationToken.None);
var rdpService = new RemoteDesktopService(this.serviceProvider);
return(rdpService.Connect(
vmInstanceReference,
"localhost",
(ushort)tunnel.LocalPort,
new VmInstanceConnectionSettings()
{
Username = credentials.UserName,
Password = credentials.SecurePassword,
AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication,
BitmapPersistence = RdpBitmapPersistence.Disabled,
DesktopSize = RdpDesktopSize.ClientSize
}));
}
}
public async Task WhenCredentialsValid_ThenConnectingSucceeds(
[Values(RdpConnectionBarState.AutoHide, RdpConnectionBarState.Off, RdpConnectionBarState.Pinned)]
RdpConnectionBarState connectionBarState,
[Values(RdpDesktopSize.ClientSize, RdpDesktopSize.ScreenSize)]
RdpDesktopSize desktopSize,
[Values(RdpAudioMode.DoNotPlay, RdpAudioMode.PlayLocally, RdpAudioMode.PlayOnServer)]
RdpAudioMode audioMode,
[Values(RdpRedirectClipboard.Disabled, RdpRedirectClipboard.Enabled)]
RdpRedirectClipboard redirectClipboard,
// Use a slightly larger machine type as all this RDP'ing consumes a fair
// amount of memory.
[WindowsInstance(MachineType = "n1-standard-2")] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(testInstance.InstanceReference))
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationService>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
testInstance.InstanceReference,
"test",
CancellationToken.None);
var rdpService = new RemoteDesktopService(this.serviceProvider);
var session = rdpService.Connect(
testInstance.InstanceReference,
"localhost",
(ushort)tunnel.LocalPort,
new VmInstanceSettings()
{
Username = credentials.UserName,
Password = credentials.SecurePassword,
ConnectionBar = connectionBarState,
DesktopSize = desktopSize,
AudioMode = audioMode,
RedirectClipboard = redirectClipboard,
AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication,
BitmapPersistence = RdpBitmapPersistence.Disabled
});
AwaitEvent <RemoteDesktopConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
RemoteDesktopWindowClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <RemoteDesktopWindowClosedEvent>(e =>
{
expectedEvent = e;
});
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
public async Task WhenCredentialsInvalid_ThenErrorIsShownAndWindowIsClosed(
[WindowsInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
locator,
await credential))
{
var settings = VmInstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.Username.StringValue = "wrong";
settings.Password.Value = SecureStringExtensions.FromClearText("wrong");
settings.AuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
settings.UserAuthenticationBehavior.EnumValue = RdpUserAuthenticationBehavior.AbortOnFailure;
settings.DesktopSize.EnumValue = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
var session = rdpService.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <ConnectionFailedEvent>();
Assert.IsNotNull(this.ExceptionShown);
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(2055, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
}
public async Task WhenSetClientConnectionEncryptionLevelSetToLow_ThenConnectionSucceeds(
[WindowsInstance(InitializeScript = @"
& reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v MinEncryptionLevel /d 1 /f | Out-Default
")] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
locator,
await credential))
{
var session = await Connect(tunnel, locator);
AwaitEvent <RemoteDesktopConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
RemoteDesktopWindowClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <RemoteDesktopWindowClosedEvent>(e =>
{
expectedEvent = e;
});
Delay(TimeSpan.FromSeconds(5));
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
private async Task <IRemoteDesktopSession> Connect(
RdpTunnel tunnel,
InstanceLocator vmInstanceReference)
{
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
vmInstanceReference,
CreateRandomUsername(),
TimeSpan.FromSeconds(60),
CancellationToken.None);
var settings = VmInstanceConnectionSettings.CreateNew(vmInstanceReference);
settings.Username.Value = credentials.UserName;
settings.Password.Value = credentials.SecurePassword;
settings.AuthenticationLevel.Value = RdpAuthenticationLevel.NoServerAuthentication;
settings.BitmapPersistence.Value = RdpBitmapPersistence.Disabled;
settings.DesktopSize.Value = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
return(rdpService.Connect(
vmInstanceReference,
"localhost",
(ushort)tunnel.LocalPort,
settings));
}
}
public async Task WhenCredentialsInvalid_ThenErrorIsShownAndWindowIsClosed(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(testInstance.InstanceReference))
{
var rdpService = new RemoteDesktopService(this.serviceProvider);
var session = rdpService.Connect(
testInstance.InstanceReference,
"localhost",
(ushort)tunnel.LocalPort,
new VmInstanceSettings()
{
Username = "******",
Password = SecureStringExtensions.FromClearText("wrong"),
AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication,
UserAuthenticationBehavior = RdpUserAuthenticationBehavior.AbortOnFailure
});
AwaitEvent <RemoteDesktopConnectionFailedEvent>();
Assert.IsNotNull(this.ExceptionShown);
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(2055, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
}
public async Task WhenRequireUserAuthenticationForRemoteConnectionsByNlaEnabled_ThenConnectionSucceeds(
[WindowsInstance(InitializeScript = @"
& reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v UserAuthentication /d 1 /f | Out-Default
")] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(testInstance.InstanceReference))
{
var session = await Connect(tunnel, testInstance.InstanceReference);
AwaitEvent <RemoteDesktopConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
RemoteDesktopWindowClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <RemoteDesktopWindowClosedEvent>(e =>
{
expectedEvent = e;
});
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
public async Task WhenRequireUseOfSpecificSecurityLayerForRdpConnectionsSetToSsl_ThenConnectionSucceeds(
[WindowsInstance(InitializeScript = @"
& reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v SecurityLayer /d 2 /f | Out-Default
")] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
locator,
await credential))
{
var session = await Connect(tunnel, locator);
AwaitEvent <SessionStartedEvent>();
Assert.IsNull(this.ExceptionShown);
SessionEndedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <SessionEndedEvent>(e =>
{
expectedEvent = e;
});
Delay(TimeSpan.FromSeconds(5));
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
public async Task WhenRequireUseOfSpecificSecurityLayerForRdpConnectionsSetToSsl_ThenConnectionSucceeds(
[WindowsInstance(InitializeScript = @"
& reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v SecurityLayer /d 2 /f | Out-Default
")] InstanceRequest testInstance,
[Credential] CredentialRequest credential)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(
testInstance.Locator,
await credential.GetCredentialAsync()))
{
var session = await Connect(tunnel, testInstance.Locator);
AwaitEvent <RemoteDesktopConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
RemoteDesktopWindowClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <RemoteDesktopWindowClosedEvent>(e =>
{
expectedEvent = e;
});
Delay(TimeSpan.FromSeconds(5));
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
public async Task WhenConnected_ThenActiveSessionIsSetAndTryActivateReturnsTrue(
[WindowsInstance(MachineType = MachineTypeForRdp)] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
locator,
await credential))
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
locator,
CreateRandomUsername(),
TimeSpan.FromSeconds(60),
CancellationToken.None);
var settings = VmInstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.Username.StringValue = credentials.UserName;
settings.Password.Value = credentials.SecurePassword;
var broker = new RemoteDesktopConnectionBroker(this.serviceProvider);
var session = broker.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <ConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
Assert.IsTrue(broker.IsConnected(locator));
Assert.AreSame(session, broker.ActiveSession);
Assert.IsTrue(broker.TryActivate(locator));
Assert.IsFalse(broker.TryActivate(SampleLocator));
Assert.IsFalse(broker.IsConnected(SampleLocator));
ConnectionClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <ConnectionClosedEvent>(e =>
{
expectedEvent = e;
});
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
public async Task WhenSigningOutPerSendKeys_ThenWindowIsClosed(
[WindowsInstance(ImageFamily = WindowsInstanceAttribute.WindowsServer2019)]
ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
locator,
await credential))
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
locator,
CreateRandomUsername(),
TimeSpan.FromSeconds(60),
CancellationToken.None);
var settings = VmInstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.Username.StringValue = credentials.UserName;
settings.Password.Value = credentials.SecurePassword;
settings.AuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
settings.BitmapPersistence.EnumValue = RdpBitmapPersistence.Disabled;
settings.DesktopSize.EnumValue = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
var session = (RemoteDesktopPane)rdpService.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <ConnectionSuceededEvent>();
Thread.Sleep(5000);
session.ShowSecurityScreen();
Thread.Sleep(1000);
session.SendKeys(Keys.Menu, Keys.S); // Sign out.
AwaitEvent <ConnectionClosedEvent>();
Assert.IsNull(this.ExceptionShown);
}
}
public async Task WhenAllowUsersToConnectRemotelyByUsingRdsIsOff_ThenErrorIsShownAndWindowIsClosed(
[WindowsInstance(InitializeScript = @"
# Disable Policy
& reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v fDenyTSConnections /d 1 /f | Out-Default
")] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(testInstance.InstanceReference))
{
var session = await Connect(tunnel, testInstance.InstanceReference);
AwaitEvent <RemoteDesktopConnectionFailedEvent>();
Assert.IsNotNull(this.ExceptionShown);
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(264, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
}
public async Task WhenSigningOutPerSendKeys_ThenWindowIsClosed(
[WindowsInstance(ImageFamily = WindowsInstanceAttribute.WindowsServer2019)]
InstanceRequest testInstance,
[Credential] CredentialRequest credential)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(
testInstance.Locator,
await credential.GetCredentialAsync()))
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
testInstance.Locator,
CreateRandomUsername(),
CancellationToken.None);
var rdpService = new RemoteDesktopService(this.serviceProvider);
var session = (RemoteDesktopPane)rdpService.Connect(
testInstance.Locator,
"localhost",
(ushort)tunnel.LocalPort,
new VmInstanceConnectionSettings()
{
Username = credentials.UserName,
Password = credentials.SecurePassword,
AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication,
BitmapPersistence = RdpBitmapPersistence.Disabled,
DesktopSize = RdpDesktopSize.ClientSize
});
AwaitEvent <RemoteDesktopConnectionSuceededEvent>();
Thread.Sleep(5000);
session.ShowSecurityScreen();
Thread.Sleep(1000);
session.SendKeys(Keys.Menu, Keys.S); // Sign out.
AwaitEvent <RemoteDesktopWindowClosedEvent>();
Assert.IsNull(this.ExceptionShown);
}
}
public async Task WhenAllowUsersToConnectRemotelyByUsingRdsIsOff_ThenErrorIsShownAndWindowIsClosed(
[WindowsInstance(InitializeScript = @"
# Disable Policy
& reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v fDenyTSConnections /d 1 /f | Out-Default
")] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
locator,
await credential))
{
var session = await Connect(tunnel, locator);
AwaitEvent <RemoteDesktopConnectionFailedEvent>();
Assert.IsNotNull(this.ExceptionShown);
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(264, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
}
public async Task WhenCredentialsValid_ThenConnectingSucceeds(
[Values(RdpConnectionBarState.AutoHide, RdpConnectionBarState.Off, RdpConnectionBarState.Pinned)]
RdpConnectionBarState connectionBarState,
[Values(RdpDesktopSize.ClientSize, RdpDesktopSize.ScreenSize)]
RdpDesktopSize desktopSize,
[Values(RdpAudioMode.DoNotPlay, RdpAudioMode.PlayLocally, RdpAudioMode.PlayOnServer)]
RdpAudioMode audioMode,
[Values(RdpRedirectClipboard.Disabled, RdpRedirectClipboard.Enabled)]
RdpRedirectClipboard redirectClipboard,
// Use a slightly larger machine type as all this RDP'ing consumes a fair
// amount of memory.
[WindowsInstance(MachineType = "n1-standard-2")] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
locator,
await credential))
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
locator,
CreateRandomUsername(),
TimeSpan.FromSeconds(60),
CancellationToken.None);
var settings = VmInstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.Username.StringValue = credentials.UserName;
settings.Password.Value = credentials.SecurePassword;
settings.ConnectionBar.EnumValue = connectionBarState;
settings.DesktopSize.EnumValue = desktopSize;
settings.AudioMode.EnumValue = audioMode;
settings.RedirectClipboard.EnumValue = redirectClipboard;
settings.AuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
settings.BitmapPersistence.EnumValue = RdpBitmapPersistence.Disabled;
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
var session = rdpService.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <ConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
ConnectionClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <ConnectionClosedEvent>(e =>
{
expectedEvent = e;
});
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
