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 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 void WhenSettingIsNull_ThenSaveResetsRegistry()
{
using (var key = this.hkcu.CreateSubKey(TestKeyPath))
{
var setting = RegistrySecureStringSetting.FromKey(
"test",
"title",
"description",
"category",
key,
DataProtectionScope.CurrentUser);
setting.Value = SecureStringExtensions.FromClearText("red");
setting.Save(key);
Assert.IsNotNull(key.GetValue("test"));
// Now write again.
setting = RegistrySecureStringSetting.FromKey(
"test",
"title",
"description",
"category",
key,
DataProtectionScope.CurrentUser);
setting.Value = null;
setting.Save(key);
Assert.IsNull(key.GetValue("test"));
}
}
public async Task WhenConnectingByUrlWithUsernameAndCredentialsExist_ThenConnectionIsMadeWithUsernameFromUrl()
{
var settings = new VmInstanceConnectionSettings()
{
Username = "******",
Password = SecureStringExtensions.FromClearText("password")
};
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettingsEditor(
It.IsAny <IProjectExplorerNode>()))
.Returns(new ConnectionSettingsEditor(
settings,
_ => { },
null));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference)
.Returns(new InstanceLocator("project-1", "zone-1", "instance-1"));
this.serviceRegistry.AddMock <ICredentialPrompt>()
.Setup(p => p.ShowCredentialsPromptAsync(
It.IsAny <IWin32Window>(),
It.IsAny <InstanceLocator>(),
It.IsAny <ConnectionSettingsEditor>(),
It.IsAny <bool>()));
this.serviceRegistry.AddMock <IProjectExplorer>()
.Setup(p => p.TryFindNode(
It.IsAny <InstanceLocator>()))
.Returns(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopConnectionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <VmInstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopConnectionBroker>(remoteDesktopService.Object);
var service = new IapRdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(
IapRdpUrl.FromString("iap-rdp:///project/us-central-1/instance-1?username=john%20doe"));
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <VmInstanceConnectionSettings>(i => i.Username == "john doe")), Times.Once);
settingsService.Verify(s => s.GetConnectionSettingsEditor(
It.IsAny <IProjectExplorerNode>()), Times.Once);
}
public async Task WhenConnectingByUrlWithUsernameAndCredentialsExist_ThenConnectionIsMadeWithUsernameFromUrl()
{
var settings = InstanceConnectionSettings.CreateNew("project", "instance-1");
settings.RdpUsername.Value = "existinguser";
settings.RdpPassword.Value = SecureStringExtensions.FromClearText("password");
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(
It.IsAny <IProjectModelNode>()))
.Returns(
settings.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = new Mock <IProjectModelInstanceNode>();
vmNode.SetupGet(n => n.Instance)
.Returns(new InstanceLocator("project-1", "zone-1", "instance-1"));
this.serviceRegistry.AddMock <ICredentialPrompt>()
.Setup(p => p.ShowCredentialsPromptAsync(
It.IsAny <IWin32Window>(),
It.IsAny <InstanceLocator>(),
It.IsAny <ConnectionSettingsBase>(),
It.IsAny <bool>()));
this.serviceRegistry.AddMock <IProjectModelService>()
.Setup(p => p.GetNodeAsync(
It.IsAny <ResourceLocator>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopSessionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <InstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopSessionBroker>(remoteDesktopService.Object);
var service = new RdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(
IapRdpUrl.FromString("iap-rdp:///project/us-central-1/instance-1?username=john%20doe"));
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <InstanceConnectionSettings>(i => i.RdpUsername.StringValue == "john doe")), Times.Once);
settingsService.Verify(s => s.GetConnectionSettings(
It.IsAny <IProjectModelNode>()), Times.Once);
}
public async Task WhenConnectingByNodeAndPersistentCredentialsAllowed_ThenCredentialsAreUsed()
{
var settings = InstanceConnectionSettings.CreateNew("project", "instance-1");
settings.RdpUsername.Value = "existinguser";
settings.RdpPassword.Value = SecureStringExtensions.FromClearText("password");
bool settingsSaved = false;
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(
It.IsAny <IProjectExplorerNode>()))
.Returns(
settings.ToPersistentSettingsCollection(s => settingsSaved = true));
var vmNode = new Mock <IProjectExplorerInstanceNode>();
vmNode.SetupGet(n => n.Instance)
.Returns(new InstanceLocator("project-1", "zone-1", "instance-1"));
this.serviceRegistry.AddMock <IProjectExplorer>()
.Setup(p => p.TryFindNode(
It.IsAny <InstanceLocator>()))
.Returns(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopSessionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <InstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopSessionBroker>(remoteDesktopService.Object);
var service = new RdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object, true);
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <InstanceConnectionSettings>(i =>
i.RdpUsername.StringValue == "existinguser" &&
i.RdpPassword.ClearTextValue == "password")), Times.Once);
Assert.IsTrue(settingsSaved);
}
public override void SetValue(object component, object value)
{
//
// NB. Avoid converting null to a SecureString as this results
// in an empty string - which would then be treated as non-default.
//
if (value == null)
{
ResetValue(component);
}
else
{
this.setting.Value = SecureStringExtensions.FromClearText((string)value);
}
}
public void WhenSettingsSaved_GetSettingsReturnsData()
{
var baseKey = hkcu.CreateSubKey(TestKeyPath);
var repository = new AuthSettingsRepository(baseKey);
var originalSettings = repository.GetSettings();
originalSettings.Credentials.Value = SecureStringExtensions.FromClearText("secure");
repository.SetSettings(originalSettings);
var settings = repository.GetSettings();
Assert.AreEqual(
"secure",
settings.Credentials.ClearTextValue);
}
public async Task WhenConnectingByNodeAndPersistentCredentialsDisallowed_ThenPasswordIsClear()
{
var settings = VmInstanceConnectionSettings.CreateNew("project", "instance-1");
settings.Username.Value = "existinguser";
settings.Password.Value = SecureStringExtensions.FromClearText("password");
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(
It.IsAny <IProjectExplorerNode>()))
.Returns(settings);
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference)
.Returns(new InstanceLocator("project-1", "zone-1", "instance-1"));
this.serviceRegistry.AddMock <IProjectExplorer>()
.Setup(p => p.TryFindNode(
It.IsAny <InstanceLocator>()))
.Returns(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopSessionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <VmInstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopSessionBroker>(remoteDesktopService.Object);
var service = new IapRdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object, false);
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <VmInstanceConnectionSettings>(i =>
i.Username.StringValue == "existinguser" &&
i.Password.ClearTextValue == "")), Times.Once);
settingsService.Verify(s => s.SaveConnectionSettings(
It.IsAny <ConnectionSettingsBase>()), Times.Never);
}
public void WhenSecureStringStored_StringCanBeDecrypted()
{
this.hkcu.DeleteSubKeyTree(TestKeyPath, false);
var registryKey = hkcu.CreateSubKey(TestKeyPath);
var original = new KeyWithSecureString()
{
Secure = SecureStringExtensions.FromClearText("secure!!!")
};
new RegistryBinder <KeyWithSecureString>().Store(original, registryKey);
var copy = new RegistryBinder <KeyWithSecureString>().Load(registryKey);
Assert.AreEqual(
"secure!!!",
copy.Secure.AsClearText());
}
public Task StoreAsync <T>(string key, T value)
{
Utilities.ThrowIfNullOrEmpty(key, nameof(key));
if (key == CredentialStoreKey)
{
var settings = GetSettings();
settings.Credentials.Value = SecureStringExtensions.FromClearText(
NewtonsoftJsonSerializer.Instance.Serialize(value));
SetSettings(settings);
return(Task.CompletedTask);
}
else
{
throw new KeyNotFoundException(key);
}
}
public void WhenValueDiffersFromDefault_ThenSetValueSucceedsAndSettingIsDirty()
{
using (var key = this.hkcu.CreateSubKey(TestKeyPath))
{
var setting = RegistrySecureStringSetting.FromKey(
"test",
"title",
"description",
"category",
key,
DataProtectionScope.CurrentUser);
setting.Value = SecureStringExtensions.FromClearText("yellow");
Assert.IsFalse(setting.IsDefault);
Assert.IsTrue(setting.IsDirty);
}
}
public void WhenValueIsNull_ThenSetValueResetsToDefault()
{
using (var key = this.hkcu.CreateSubKey(TestKeyPath))
{
var setting = RegistrySecureStringSetting.FromKey(
"test",
"title",
"description",
"category",
key,
DataProtectionScope.CurrentUser);
setting.Value = SecureStringExtensions.FromClearText("blue");
setting.Value = null;
Assert.IsNull(setting.Value);
Assert.IsTrue(setting.IsDefault);
}
}
public async Task WhenConnectingByNodeAndPersistentCredentialsDisallowed_ThenPasswordIsClear()
{
var settings = InstanceConnectionSettings.CreateNew("project", "instance-1");
settings.RdpUsername.Value = "existinguser";
settings.RdpPassword.Value = SecureStringExtensions.FromClearText("password");
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(
It.IsAny <IProjectModelNode>()))
.Returns(
settings.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = CreateInstanceNodeMock();
this.serviceRegistry.AddMock <IProjectModelService>()
.Setup(p => p.GetNodeAsync(
It.IsAny <ResourceLocator>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopSessionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <InstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopSessionBroker>(remoteDesktopService.Object);
var service = new RdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object, false);
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <InstanceConnectionSettings>(i =>
i.RdpUsername.StringValue == "existinguser" &&
i.RdpPassword.ClearTextValue == "")), Times.Once);
}
public void WhenSecureStringIsDeleted_RemainsNull()
{
this.hkcu.DeleteSubKeyTree(TestKeyPath, false);
var registryKey = hkcu.CreateSubKey(TestKeyPath);
new RegistryBinder <KeyWithSecureString>().Store(
new KeyWithSecureString()
{
Secure = SecureStringExtensions.FromClearText("secure!!!")
},
registryKey);
new RegistryBinder <KeyWithSecureString>().Store(
new KeyWithSecureString()
{
Secure = null
},
registryKey);
var copy = new RegistryBinder <KeyWithSecureString>().Load(registryKey);
Assert.IsNull(copy.Secure);
}
public void WhenRegistryValueExists_ThenFromKeyUsesValue()
{
using (var key = this.hkcu.CreateSubKey(TestKeyPath))
{
var setting = RegistrySecureStringSetting.FromKey(
"test",
"title",
"description",
"category",
key,
DataProtectionScope.CurrentUser);
setting.Value = SecureStringExtensions.FromClearText("red");
setting.Save(key);
Assert.IsNotNull(key.GetValue("test"));
// Now read again.
setting = RegistrySecureStringSetting.FromKey(
"test",
"title",
"description",
"category",
key,
DataProtectionScope.CurrentUser);
Assert.AreEqual("test", setting.Key);
Assert.AreEqual("title", setting.Title);
Assert.AreEqual("description", setting.Description);
Assert.AreEqual("category", setting.Category);
Assert.AreEqual("red", setting.ClearTextValue);
Assert.IsFalse(setting.IsDefault);
Assert.IsFalse(setting.IsDirty);
}
}
