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 = IapTunnel.ForRdp(
                       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);
            }
        }
        private async Task <IRemoteDesktopSession> Connect(
            IapTunnel 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 = InstanceConnectionSettings.CreateNew(vmInstanceReference);
                settings.RdpUsername.Value            = credentials.UserName;
                settings.RdpPassword.Value            = credentials.SecurePassword;
                settings.RdpAuthenticationLevel.Value = RdpAuthenticationLevel.NoServerAuthentication;
                settings.RdpBitmapPersistence.Value   = RdpBitmapPersistence.Disabled;
                settings.RdpDesktopSize.Value         = RdpDesktopSize.ClientSize;

                var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
                return(rdpService.Connect(
                           vmInstanceReference,
                           "localhost",
                           (ushort)tunnel.LocalPort,
                           settings));
            }
        }
        public async Task WhenCredentialsInvalid_ThenErrorIsShownAndWindowIsClosed(
            [WindowsInstance(MachineType = MachineTypeForRdp)] ResourceTask <InstanceLocator> testInstance,
            [Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
        {
            var locator = await testInstance;

            using (var tunnel = IapTunnel.ForRdp(
                       locator,
                       await credential))
            {
                var settings = InstanceConnectionSettings.CreateNew(
                    locator.ProjectId,
                    locator.Name);
                settings.RdpUsername.StringValue                 = "wrong";
                settings.RdpPassword.Value                       = SecureStringExtensions.FromClearText("wrong");
                settings.RdpAuthenticationLevel.EnumValue        = RdpAuthenticationLevel.NoServerAuthentication;
                settings.RdpUserAuthenticationBehavior.EnumValue = RdpUserAuthenticationBehavior.AbortOnFailure;
                settings.RdpDesktopSize.EnumValue                = RdpDesktopSize.ClientSize;

                var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
                var session    = rdpService.Connect(
                    locator,
                    "localhost",
                    (ushort)tunnel.LocalPort,
                    settings);

                AwaitEvent <SessionAbortedEvent>();
                Assert.IsNotNull(this.ExceptionShown);
                Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
                Assert.AreEqual(2055, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
            }
        }
        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 = IapTunnel.ForRdp(
                       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 = InstanceConnectionSettings.CreateNew(
                        locator.ProjectId,
                        locator.Name);
                    settings.RdpUsername.StringValue          = credentials.UserName;
                    settings.RdpPassword.Value                = credentials.SecurePassword;
                    settings.RdpAuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
                    settings.RdpBitmapPersistence.EnumValue   = RdpBitmapPersistence.Disabled;
                    settings.RdpDesktopSize.EnumValue         = RdpDesktopSize.ClientSize;

                    var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
                    var session    = (RemoteDesktopPane)rdpService.Connect(
                        locator,
                        "localhost",
                        (ushort)tunnel.LocalPort,
                        settings);

                    AwaitEvent <SessionStartedEvent>();

                    Thread.Sleep(5000);
                    session.ShowSecurityScreen();
                    Thread.Sleep(1000);
                    session.SendKeys(Keys.Menu, Keys.S); // Sign out.

                    AwaitEvent <SessionEndedEvent>();
                    Assert.IsNull(this.ExceptionShown);
                }
        }
Beispiel #5
0
        public async Task WhenConnected_ThenGetActivePaneReturnsPane(
            [WindowsInstance(MachineType = MachineTypeForRdp)] ResourceTask <InstanceLocator> testInstance,
            [Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
        {
            var locator = await testInstance;

            using (var tunnel = IapTunnel.ForRdp(
                       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 = InstanceConnectionSettings.CreateNew(
                        locator.ProjectId,
                        locator.Name);
                    settings.RdpUsername.StringValue = credentials.UserName;
                    settings.RdpPassword.Value       = credentials.SecurePassword;

                    // Connect
                    var broker = new RemoteDesktopSessionBroker(this.serviceProvider);
                    IRemoteDesktopSession session = null;
                    AssertRaisesEvent <SessionStartedEvent>(
                        () => session = (RemoteDesktopPane)broker.Connect(
                            locator,
                            "localhost",
                            (ushort)tunnel.LocalPort,
                            settings));

                    Assert.IsNull(this.ExceptionShown);

                    Assert.AreSame(session, RemoteDesktopPane.TryGetActivePane(this.mainForm));
                    Assert.AreSame(session, RemoteDesktopPane.TryGetExistingPane(this.mainForm, locator));
                    Assert.IsTrue(broker.IsConnected(locator));
                    Assert.IsTrue(broker.TryActivate(locator));

                    AssertRaisesEvent <SessionEndedEvent>(
                        () => session.Close());
                }
        }
        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 = IapTunnel.ForRdp(
                       locator,
                       await credential))
            {
                var session = await Connect(tunnel, locator);

                AwaitEvent <SessionAbortedEvent>(TimeSpan.FromSeconds(90));
                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,

            [WindowsInstance(MachineType = MachineTypeForRdp)] ResourceTask <InstanceLocator> testInstance,
            [Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
        {
            var locator = await testInstance;

            using (var tunnel = IapTunnel.ForRdp(
                       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 = InstanceConnectionSettings.CreateNew(
                        locator.ProjectId,
                        locator.Name);
                    settings.RdpUsername.StringValue          = credentials.UserName;
                    settings.RdpPassword.Value                = credentials.SecurePassword;
                    settings.RdpConnectionBar.EnumValue       = connectionBarState;
                    settings.RdpDesktopSize.EnumValue         = desktopSize;
                    settings.RdpAudioMode.EnumValue           = audioMode;
                    settings.RdpRedirectClipboard.EnumValue   = redirectClipboard;
                    settings.RdpAuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
                    settings.RdpBitmapPersistence.EnumValue   = RdpBitmapPersistence.Disabled;

                    var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
                    var session    = rdpService.Connect(
                        locator,
                        "localhost",
                        (ushort)tunnel.LocalPort,
                        settings);

                    AwaitEvent <SessionStartedEvent>();
                    Assert.IsNull(this.ExceptionShown);


                    SessionEndedEvent expectedEvent = null;

                    this.serviceProvider.GetService <IEventService>()
                    .BindHandler <SessionEndedEvent>(e =>
                    {
                        expectedEvent = e;
                    });
                    session.Close();

                    Assert.IsNotNull(expectedEvent);
                }
        }