🥇Delegowanie zarządzania sesjami RDP

W organizacji, w której pracuję, praca zdalna była zasadniczo zabroniona. Aż do zeszłego tygodnia. Teraz musieliśmy pilnie wdrożyć rozwiązanie. Od biznesu — dostosowanie procesów do nowego formatu pracy, od nas — PKI z kodami PIN i tokenami, VPN, szczegółowe logowanie i wiele innych rzeczy.
Oprócz tego zajmowałem się konfiguracją infrastruktury zdalnych pulpitów, znanej jako usługa terminali. Mamy kilka wdrożeń RDS w różnych centrach danych. Jednym z zadań było umożliwienie kolegom z pokrewnych działów IT łączenia się z sesjami użytkowników w trybie interaktywnym. Jak wiadomo, do tego służy standardowy mechanizm RDS Shadow, a najprostszym sposobem delegowania tego jest nadanie uprawnień lokalnego administratora na serwerach RDS.
Szanuję i cenię swoich kolegów, ale jestem bardzo skąpy, jeśli chodzi o przyznawanie praw administracyjnych. 🙂 Proszę tych, którzy się ze mną zgadzają, o przeczytanie dalej.

Cóż, zadanie jest jasne, teraz do dzieła.

Krok 1

Stworzymy grupę zabezpieczeń w Active Directory RDP_Operators i dodamy do niej konta tych użytkowników, którym chcemy delegować prawa:

$Users = @(
    "UserLogin1",
    "UserLogin2",
    "UserLogin3"
)
$Group = "RDP_Operators"
New-ADGroup -Name $Group -GroupCategory Security -GroupScope DomainLocal
Add-ADGroupMember -Identity $Group -Members $Users

Jeśli masz kilka witryn AD, przed przejściem do następnego kroku musisz poczekać, aż zostanie to zreplikowane na wszystkie kontrolery domeny. Zwykle zajmuje to nie więcej niż 15 minut.

Krok 2

Nadajemy grupie prawa do zarządzania sesjami terminalowymi na każdym z serwerów RDSH:

Set-RDSPermissions.ps1

$Group = "RDP_Operators"
$Servers = @(
    "RDSHost01",
    "RDSHost02",
    "RDSHost03"
)
ForEach ($Server in $Servers) {
    #Delegujemy prawo do zarządzania sesjami cieniami
    $WMIHandles = Get-WmiObject `
        -Class "Win32_TSPermissionsSetting" `
        -Namespace "rootCIMV2terminalservices" `
        -ComputerName $Server `
        -Authentication PacketPrivacy `
        -Impersonation Impersonate
    ForEach($WMIHandle in $WMIHandles)
    {
        If ($WMIHandle.TerminalName -eq "RDP-Tcp")
        {
        $retVal = $WMIHandle.AddAccount($Group, 2)
        $opstatus = "sukces"
        If ($retVal.ReturnValue -ne 0) {
            $opstatus = "błąd"
        }
        Write-Host ("Delegowanie praw do połączenia cieniowego dla grupy " +
            $Group + " na serwerze " + $Server + ": " + $opstatus + "`r`n")
        }
    }
}

Krok 3

Dodamy grupę do lokalnej grupy Użytkownicy zdalnego pulpitu na każdym z serwerów RDSH. Jeśli masz serwery zgrupowane w kolekcjach sesji, zrób to na poziomie kolekcji:

$Group = "RDP_Operators"
$CollectionName = "MyRDSCollection"
[String[]]$CurrentCollectionGroups = @(Get-RDSessionCollectionConfiguration -CollectionName $CollectionName -UserGroup).UserGroup
Set-RDSessionCollectionConfiguration -CollectionName $CollectionName -UserGroup ($CurrentCollectionGroups + $Group)

Dla pojedynczych serwerów wykorzystamy politykę grupową, czekając, aż zostanie zastosowana na serwerach. Ci, którzy nie chcą czekać, mogą wymusić proces za pomocą starego dobrego gpupdate, najlepiej centralnie.

Krok 4

Przygotujemy dla "zarządzających" taki skrypt PS:

RDSManagement.ps1

$Servers = @(
    "RDSHost01",
    "RDSHost02",
    "RDSHost03"
)

function Invoke-RDPSessionLogoff {
    Param(
        [parameter(Mandatory=$True, Position=0)][String]$ComputerName,
        [parameter(Mandatory=$true, Position=1)][String]$SessionID
    )
    $ErrorActionPreference = "Stop"
    logoff $SessionID /server:$ComputerName /v 2>&1
}

function Invoke-RDPShadowSession {
    Param(
        [parameter(Mandatory=$True, Position=0)][String]$ComputerName,
        [parameter(Mandatory=$true, Position=1)][String]$SessionID
    )
    $ErrorActionPreference = "Stop"
    mstsc /shadow:$SessionID /v:$ComputerName /control 2>&1
}

Function Get-LoggedOnUser {
    Param(
        [parameter(Mandatory=$True, Position=0)][String]$ComputerName="localhost"
    )
    $ErrorActionPreference = "Stop"
    Test-Connection $ComputerName -Count 1 | Out-Null
    quser /server:$ComputerName 2>&1 | Select-Object -Skip 1 | ForEach-Object {
        $CurrentLine = $_.Trim() -Replace "s+"," " -Split "s"
        $HashProps = @{
            UserName = $CurrentLine[0]
            ComputerName = $ComputerName
        }
        If ($CurrentLine[2] -eq "Disc") {
            $HashProps.SessionName = $null
            $HashProps.Id = $CurrentLine[1]
            $HashProps.State = $CurrentLine[2]
            $HashProps.IdleTime = $CurrentLine[3]
            $HashProps.LogonTime = $CurrentLine[4..6] -join " "
            $HashProps.LogonTime = $CurrentLine[4..($CurrentLine.GetUpperBound(0))] -join " "
        }
        else {
            $HashProps.SessionName = $CurrentLine[1]
            $HashProps.Id = $CurrentLine[2]
            $HashProps.State = $CurrentLine[3]
            $HashProps.IdleTime = $CurrentLine[4]
            $HashProps.LogonTime = $CurrentLine[5..($CurrentLine.GetUpperBound(0))] -join " "
        }
        New-Object -TypeName PSCustomObject -Property $HashProps |
        Select-Object -Property UserName, ComputerName, SessionName, Id, State, IdleTime, LogonTime
    }
}

$UserLogin = Read-Host -Prompt "Wprowadź nazwę użytkownika"
Write-Host "Szukam sesji RDP użytkownika na serwerach..."
$SessionList = @()
ForEach ($Server in $Servers) {
    $TargetSession = $null
    Write-Host "  Sprawdzam serwer $Server"
    Try {
        $TargetSession = Get-LoggedOnUser -ComputerName $Server | Where-Object {$_.UserName -eq $UserLogin}
    }
    Catch {
        Write-Host "Błąd: " $Error[0].Exception.Message -ForegroundColor Red
        Continue
    }
    If ($TargetSession) {
        Write-Host "    Znaleziono sesję z ID $($TargetSession.ID) na serwerze $Server" -ForegroundColor Yellow
        Write-Host "    Co chcesz zrobić?"
        Write-Host "      1 - połączyć się z sesją"
        Write-Host "      2 - zakończyć sesję"
        Write-Host "      0 - nic"
        $Action = Read-Host -Prompt "Wprowadź akcję"
        If ($Action -eq "1") {
            Invoke-RDPShadowSession -ComputerName $Server -SessionID $TargetSession.ID
        }
        ElseIf ($Action -eq "2") {
            Invoke-RDPSessionLogoff -ComputerName $Server -SessionID $TargetSession.ID
        }
        Break
    }
    Else {
        Write-Host "    sesje nie znalezione"
    }
}

Aby wygodnie uruchamiać skrypt PS, zrobimy dla niego powłokę w postaci pliku cmd o tej samej nazwie, co skrypt PS:

RDSManagement.cmd

@ECHO OFF
powershell -NoLogo -ExecutionPolicy Bypass -File "%~d0%~p0%~n0.ps1" %*

Umieszczamy oba pliki w folderze dostępnym dla 'zarządzających' i prosimy ich o ponowne zalogowanie. Teraz, uruchamiając plik cmd, będą mogli łączyć się z sesjami innych użytkowników w trybie RDS Shadow i wymuszać ich wylogowanie (bywa przydatne, gdy użytkownik nie może samodzielnie zakończyć 'zawieszonej' sesji).

Wygląda to mniej więcej tak:

Dla 'zarządzającego'

Dla użytkownika

Kilka uwag na koniec

Zauważenie 1. Jeśli sesja użytkownika, z którym próbujemy przejąć kontrolę, została uruchomiona przed wykonaniem skryptu Set-RDSPermissions.ps1 na serwerze, to 'zarządzający' otrzyma komunikat o błędzie dostępu. Rozwiązanie jest oczywiste: poczekać, aż zarządzany użytkownik się przeloguje.

Zauważenie 2. Po kilku dniach pracy z RDP Shadow zauważyliśmy interesujący błąd lub cechę: po zakończeniu sesji cieniowanej użytkownika, do którego się podłączaliśmy, znika panel językowy w zasobniku, a użytkownik musi się przelogować, aby go odzyskać. Jak się okazało, nie jesteśmy sami: raz, dwa, trzy.

To wszystko. Życzę zdrowia Tobie i Twoim serwerom. Jak zawsze, czekam na opinie w komentarzach i proszę o wypełnienie krótkiej ankiety poniżej.