🥇Delegerar kontroll över RDP-sessioner

I organisationen där jag arbetar är distansarbete i princip förbjudet. Det var så. Fram till förra veckan. Nu har vi hastigt varit tvungna att implementera en lösning. Från affärssidan – anpassning av processer till det nya arbetssättet, från vår sida – PKI med pinkoder och tokens, VPN, detaljerad loggning och mycket mer.
Förutom allt annat har jag arbetat med att konfigurera infrastrukturen för fjärrarbetsbord aka terminaltjänster. Vi har flera RDS-installationer på olika datacenter. En av uppgifterna var att ge kollegor från angränsande IT-avdelningar möjlighet att ansluta till användarsessioner i interaktivt läge. Som bekant finns det ett inbyggt mekanism för RDS Shadow och det enklaste sättet att delegera det är att ge lokala administratörsrättigheter på RDS-servrarna.
Jag respekterar och värdesätter mina kollegor, men jag är mycket snål med att dela ut administrativa rättigheter. 🙂 De som håller med mig, vänligen läs vidare.

Okej, uppgiften är klar, nu – till jobbet.

Steg 1

Vi skapar en säkerhetsgrupp i Active Directory RDP_Operators och lägger till användarkonton för de användare vi vill delegera rättigheter till:

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

Om ni har flera AD-webbplatser, vänta innan ni går vidare till nästa steg, tills den har replikeras på alla domänkontrollanter. Det brukar ta högst 15 minuter.

Steg 2

Vi ger gruppen rätt att hantera terminalsessioner på var och en av RDSH-servrarna:

Set-RDSPermissions.ps1

$Group = "RDP_Operators"
$Servers = @(
    "RDSHost01",
    "RDSHost02",
    "RDSHost03"
)
ForEach ($Server in $Servers) {
    # Delegerar rätt till skuggsessioner
    $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 = "framgångsrik"
        If ($retVal.ReturnValue -ne 0) {
            $opstatus = "fel"
        }
        Write-Host ("Delegating rights for shadow connection to group " +
            $Group + " on server " + $Server + ": " + $opstatus + "`r`n")
        }
    }
}

Steg 3

Lägg till gruppen i den lokala gruppen Användare av fjärrskrivbord på var och en av RDSH-servrarna. Om era servrar är sammanlänkade i sessioner, gör detta på nivå av samlingen:

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

För enskilda servrar använder vi gruppolicy, och väntar tills den tillämpas på servrarna. Den som inte vill vänta kan påskynda processen med det gamla hederliga gpupdate, helst centralt.

Steg 4

Vi förbereder en sådan PS-skript för "förvaltarna":

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 "Ange användarnamn"
Write-Host "Söker efter RDP-sessioner för användaren på servrar..."
$SessionList = @()
ForEach ($Server in $Servers) {
    $TargetSession = $null
    Write-Host "  Frågar servern $Server"
    Try {
        $TargetSession = Get-LoggedOnUser -ComputerName $Server | Where-Object {$_.UserName -eq $UserLogin}
    }
    Catch {
        Write-Host "Fel: " $Error[0].Exception.Message -ForegroundColor Red
        Continue
    }
    If ($TargetSession) {
        Write-Host "    Hittade session med ID $($TargetSession.ID) på servern $Server" -ForegroundColor Yellow
        Write-Host "    Vad vill du göra?"
        Write-Host "      1 - ansluta till sessionen"
        Write-Host "      2 - avsluta sessionen"
        Write-Host "      0 - inget"
        $Action = Read-Host -Prompt "Ange åtgärd"
        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 "    inga sessioner hittades"
    }
}

För att underlätta körningen av PS-skriptet, skapa en wrapper i form av en cmd-fil med samma namn som PS-skriptet:

RDSManagement.cmd

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

Vi lägger båda filerna i en mapp som kommer att vara tillgänglig för "administratörer" och ber dem logga in igen. Nu, genom att köra cmd-filen, kan de ansluta till andra användares sessioner i RDS Shadow-läget och tvinga dem att logga ut (detta kan vara användbart när en användare inte kan avsluta en "hängande" session själv).

Det ser ungefär ut så här:

För "administratören"

För användaren

Några sista anteckningar

Nyans 1. Om användarens session, som vi försöker få kontroll över, startades innan skriptet Set-RDSPermissions.ps1 kördes på servern, kommer "administratören" att få ett åtkomstfel. Lösningen här är uppenbar: vänta tills den styrda användaren loggar in igen.

Nyans 2. Efter några dagars arbete med RDP Shadow har vi märkt en intressant bug eller funktion: efter avslutandet av den skuggade sessionen för användaren, som vi anslöt till, försvinner språkfältet i systemfältet och för att få tillbaka det måste användaren logga in igen. Det visade sig att vi inte är ensamma: ett, två, tre.

Det är allt. Jag önskar er och era servrar välmående. Som alltid ser jag fram emot feedback i kommentarerna och ber er att delta i en kort enkät nedan.