Enable workstation remote management through native domain policies

This commit is contained in:
alexrg committed 2026-09-30 10:39:52 -06:00
1 parent 414a08ece6
commit b07dbe17d0
7 files changed
+487 -26

No files matched your search

+88 -23
View File
@@ -1,37 +1,102 @@
# Acceso remoto administrado por el dominio
`Install-SguWorkstationRemoteAccessPolicy.ps1` registra un script de inicio de
equipo en la GPO existente **SGU - Windows client experience**, vinculada a
`OU=Laboratorio`. El bootstrap del controlador lo instala después de crear esa
GPO. No crea una tarea programada en los clientes.
`Install-SguDomainRemoteManagementPolicy.ps1` crea **La Salle - Workstation
remote management**, vinculada y exigida en la raíz del dominio. Su filtro WMI
`ProductType = 1` incluye estaciones Windows 10/11, incluso las nuevas cuentas
en `CN=Computers`, y excluye servidores y controladores de dominio. Solo tiene
configuración de equipo. El bootstrap del controlador instala esta política.
La misma GPO ejecuta un segundo script de inicio para conceder administración
local a los miembros del grupo `Administrators` de Active Directory; véase
La política usa extensiones nativas de Group Policy:
- Plantillas administrativas: RDP permitido con NLA, listener WinRM y consola remota.
- Preferencias de servicios: `WinRM` y `TermService` automáticos, iniciados cuando
sea necesario; `RemoteRegistry` manual. No reinicia servicios que ya funcionan.
- Preferencias de registro: activa RDP también en la configuración local que
muestra Configuración de Windows.
- Firewall de dominio: 12 reglas para RDP TCP/UDP, WinRM, WMI, RPC, eventos,
servicios, tareas, firewall, volúmenes, rendimiento y SMB administrativo.
Los puertos RPC dinámicos se limitan al servicio correspondiente.
Por defecto, las reglas solo permiten conexiones desde `LocalSubnet`.
`-ManagementAddresses` permite especificar otras redes administrativas que
ya tengan rutas hacia las estaciones. El instalador compara valores, reglas,
archivos y vínculos; una segunda ejecución sin diferencias no modifica la GPO.
```powershell
# En PowerShell elevado del controlador de dominio:
.\scripts\Install-SguDomainRemoteManagementPolicy.ps1 -DomainController SGU-DC02
# Configuración del despliegue actual de Aula Flexible:
.\scripts\Install-SguDomainRemoteManagementPolicy.ps1 -DomainController SGU-DC02 `
-LocalDnsServer 192.168.54.211 -FallbackDnsServer 20.9.81.130 `
-ManagementAddresses @('LocalSubnet','192.168.54.211')
```
Un script de **inicio de equipo de la propia GPO** prepara el endpoint de
Windows PowerShell si está ausente o deshabilitado y comprueba el grupo RDP
institucional. No crea tareas periódicas en las estaciones. La política
preexistente **SGU - Windows client experience** conserva sus scripts de inicio
para Laboratorio y la asignación de administradores; véase
[Administradores de las estaciones Windows](workstation-administrators.md).
Al arrancar una estación Windows 10 u 11 unida al dominio, el script activa
Escritorio remoto con NLA y PowerShell Remoting, inicia `TermService` y `WinRM`,
y añade el grupo `LCI\SG-Laboratorio-Usuarios-RDP` a Usuarios de escritorio
remoto. Sus reglas de firewall admiten los puertos TCP 3389 y 5985 y UDP 3389
solo desde la subred local. En arranques siguientes comprueba el estado y solo
corrige las diferencias.
Si se proporciona DNS local, el script de inicio solo modifica una interfaz
cuyo segmento conectado contiene ese servidor, después de comprobar que
responde autoritativamente para el dominio. Puede usar otro DNS de AD como
alternativa y solicita el registro DNS del equipo. Conserva las interfaces
de otras redes.
Para aplicar una versión nueva a un cliente, ejecute PowerShell como
administrador y después reinicie:
Para aplicar la política a un cliente, ejecute PowerShell como administrador:
```powershell
gpupdate /target:computer /force
Restart-Computer
gpresult /scope computer /r
Test-ComputerSecureChannel -Verbose
Get-Service WinRM,TermService | Select-Object Name,Status,StartType
Get-NetFirewallRule -PolicyStore ActiveStore -Name 'LaSalle-Management-*' |
Select-Object Name,Enabled,PolicyStoreSourceType
```
La GPO de actualización del proveedor de credenciales también se ejecuta al
inicio de equipo; `gpupdate` sin reiniciar no instala el proveedor nuevo.
Compruebe la aplicación con `gpresult /scope computer /r`, `Test-WSMan` y una
conexión RDP desde la misma subred. Si el equipo no puede autenticarse ante
el controlador (`Test-ComputerSecureChannel` devuelve `False`), repare primero
la relación de confianza desde el propio cliente con credenciales de dominio
autorizadas; un equipo sin canal seguro no puede recibir de forma fiable sus
políticas. No elimine ni vuelva a crear su objeto de AD para forzar una GPO.
La GPO debe figurar aplicada, el canal seguro devolver `True`, ambos servicios
estar activos y las 12 reglas habilitadas con origen `GroupPolicy`.
`gpupdate` aplica registro, servicios y firewall sin cerrar la sesión. Reiniciar
una vez ejecuta además la preparación inicial del endpoint y DNS. La actualización
del proveedor de credenciales es otra GPO de inicio y necesita su propio reinicio.
Para revisar varias estaciones desde SGU-DC02, con una cuenta de administración
del dominio:
```powershell
.\scripts\Get-SguWorkstationRemoteManagementStatus.ps1 -ComputerName `
AF-02.lci.lasalle.mx,AF-03.lci.lasalle.mx -RefreshPolicy | Format-Table
# Sin ComputerName, consulta todas las estaciones Windows habilitadas de AD.
.\scripts\Get-SguWorkstationRemoteManagementStatus.ps1 | Format-Table
```
Un cliente con canal seguro roto necesita primero reparar su relación de
confianza con credenciales autorizadas. No elimine su objeto de AD para forzar
la aplicación de una política. Un equipo apagado o sin conectividad recibirá
la configuración cuando vuelva a contactar con el dominio.
Las GPO habilitan la administración de las estaciones. El inventario de conexiones
de WAC se mantiene en el gateway y se registra por separado:
```powershell
.\scripts\Sync-SguWacDomainConnections.ps1 -Endpoint https://sgu-dc02/ `
-Credential (Get-Credential 'LCI\azureadmin') -DomainController SGU-DC02
```
El script usa el inicio de sesión nativo de WAC v2 mediante HTTPS, CSRF y
RSA-OAEP-SHA256. No cambia la autenticación ni almacena la contraseña. Añade
conexiones **compartidas** para las cuentas Windows habilitadas de AD que tengan
nombre DNS, conserva las conexiones existentes y verifica que no falte ninguna.
Si se repite, no vuelve a añadir las mismas conexiones. Ejecútelo de nuevo al
añadir equipos al dominio, o use **Agregar → Buscar en Active Directory** en WAC;
no hay un sondeo periódico instalado para mantener esta lista.
`-VerifyNodes AF-02.lci.lasalle.mx,AF-03.lci.lasalle.mx` comprueba además que el
gateway pueda consultar instancias del sistema operativo mediante su API CIM.
La presencia de una conexión en la lista no implica que esté encendida.
Desde un equipo administrador no unido al dominio, PowerShell Remoting por
HTTP requiere indicar `-Credential` y confiar explícitamente en el destino
+67 -3
View File
@@ -1,9 +1,53 @@
[CmdletBinding()]
param([string]$RemoteDesktopPrincipal = 'LCI\SG-Laboratorio-Usuarios-RDP')
param(
[string]$RemoteDesktopPrincipal = 'LCI\SG-Laboratorio-Usuarios-RDP',
[string]$LocalDnsServer = '',
[string]$FallbackDnsServer = ''
)
$ErrorActionPreference = 'Stop'
$computer = Get-CimInstance Win32_ComputerSystem
if (-not $computer.PartOfDomain -or $computer.DomainRole -ge 4) { return }
if (-not $computer.PartOfDomain -or $computer.DomainRole -ne 1) { return }
# A site-local DNS server is optional. Change only an adapter whose directly
# connected subnet contains that server, after verifying its authoritative DNS
# answer. Other sites, VPN adapters and Internet-only interfaces are preserved.
if ($LocalDnsServer) {
$dnsBytes = ([Net.IPAddress]::Parse($LocalDnsServer)).GetAddressBytes()
foreach ($ip in @(Get-NetIPAddress -AddressFamily IPv4 | Where-Object {
$_.AddressState -eq 'Preferred' -and $_.PrefixLength -gt 0 -and $_.PrefixLength -lt 32
})) {
$ipBytes = ([Net.IPAddress]::Parse($ip.IPAddress)).GetAddressBytes()
$sameSubnet = $true
for ($bit = 0; $bit -lt $ip.PrefixLength; $bit++) {
$mask = 1 -shl (7 - ($bit % 8))
$index = [int][Math]::Floor($bit / 8)
if (($ipBytes[$index] -band $mask) -ne ($dnsBytes[$index] -band $mask)) {
$sameSubnet = $false; break
}
}
if (-not $sameSubnet) { continue }
try {
$authority = @(Resolve-DnsName -Name $computer.Domain -Type SOA -Server $LocalDnsServer -DnsOnly -ErrorAction Stop |
Where-Object { $_.Name -ieq $computer.Domain -and $_.Type -eq 'SOA' })
if (-not $authority) { throw 'The DNS server did not return the domain SOA.' }
$desiredServers = @($LocalDnsServer)
if ($FallbackDnsServer) {
[Net.IPAddress]::Parse($FallbackDnsServer) | Out-Null
$fallbackAuthority = @(Resolve-DnsName -Name $computer.Domain -Type SOA -Server $FallbackDnsServer -DnsOnly -ErrorAction Stop |
Where-Object { $_.Name -ieq $computer.Domain -and $_.Type -eq 'SOA' })
if (-not $fallbackAuthority) { throw 'Fallback DNS is not authoritative for this domain.' }
$desiredServers += $FallbackDnsServer
}
$current = (Get-DnsClientServerAddress -InterfaceIndex $ip.InterfaceIndex -AddressFamily IPv4).ServerAddresses
if ((@($current) -join ',') -ne ($desiredServers -join ',')) {
Set-DnsClientServerAddress -InterfaceIndex $ip.InterfaceIndex -ServerAddresses $desiredServers
}
Set-DnsClient -InterfaceIndex $ip.InterfaceIndex -RegisterThisConnectionsAddress $true
Register-DnsClient
} catch { Write-Warning "Site DNS configuration failed: $($_.Exception.Message)" }
}
}
$terminalKey = 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server'
$rdpKey = Join-Path $terminalKey 'WinStations\RDP-Tcp'
@@ -49,10 +93,30 @@ foreach ($rule in $rules) {
$listener = @(Get-ChildItem WSMan:\localhost\Listener -ErrorAction SilentlyContinue |
Where-Object { $_.Keys -contains 'Transport=HTTP' })
$endpoint = Get-PSSessionConfiguration -Name Microsoft.PowerShell -ErrorAction SilentlyContinue
if (-not $listener -or -not $endpoint) {
$endpointEnabled = Get-Item 'WSMan:\localhost\Plugin\Microsoft.PowerShell\Enabled' -ErrorAction SilentlyContinue
if (-not $listener -or -not $endpoint -or $endpointEnabled.Value -eq 'false') {
Enable-PSRemoting -Force -SkipNetworkProfileCheck | Out-Null
}
# Native, language-independent rule names. The domain policy also distributes
# these rules through the firewall CSE, so background gpupdate can repair them.
$managementPatterns = @('RemoteEventLogSvc-*', 'RemoteSvcAdmin-*', 'WMI-*',
'RemoteTask-*', 'RemoteFwAdmin-*', 'RVM-*', 'PerfLogsAlerts-*', 'FPS-SMB-In-TCP*')
foreach ($pattern in $managementPatterns) {
foreach ($nativeRule in @(Get-NetFirewallRule -Name $pattern -ErrorAction SilentlyContinue |
Where-Object Direction -eq 'Inbound')) {
# Do not try to mutate policy-owned rules in the workstation local store.
if ($nativeRule.PolicyStoreSourceType -ne 'Local') { continue }
$address = $nativeRule | Get-NetFirewallAddressFilter
if ($nativeRule.Enabled -ne 'True' -or $nativeRule.Profile -ne 'Any' -or
@($address.RemoteAddress).Count -ne 1 -or $address.RemoteAddress[0] -ne 'LocalSubnet') {
$nativeRule | Set-NetFirewallRule -Enabled True -Profile Any -RemoteAddress LocalSubnet
}
}
}
$remoteRegistry = Get-Service RemoteRegistry
if ($remoteRegistry.StartType -ne 'Manual') { Set-Service RemoteRegistry -StartupType Manual }
# The built-in local group has a stable SID across Windows display languages.
$groupSid = [Security.Principal.SecurityIdentifier]::new('S-1-5-32-555')
$groupName = ($groupSid.Translate([Security.Principal.NTAccount]).Value -split '\\', 2)[1]
@@ -0,0 +1,39 @@
[CmdletBinding()]
param(
[string[]]$ComputerName,
[PSCredential]$Credential,
[string]$DomainController = $env:COMPUTERNAME,
[switch]$RefreshPolicy
)
$ErrorActionPreference = 'Stop'
if (-not $ComputerName) {
Import-Module ActiveDirectory
$ComputerName = @(Get-ADComputer -Server $DomainController -Filter 'Enabled -eq $true' -Properties OperatingSystem,DNSHostName |
Where-Object { $_.DNSHostName -and $_.OperatingSystem -like 'Windows*' -and $_.OperatingSystem -notlike '*Server*' } |
Select-Object -ExpandProperty DNSHostName)
}
foreach ($name in $ComputerName) {
try {
$parameters = @{ComputerName=$name;Authentication='Kerberos';ErrorAction='Stop';
SessionOption=(New-PSSessionOption -OpenTimeout 10000 -OperationTimeout 90000)}
if ($Credential) { $parameters.Credential = $Credential }
Invoke-Command @parameters -ArgumentList ([bool]$RefreshPolicy) -ScriptBlock {
param($refresh)
$exitCode = $null
if ($refresh) { gpupdate /target:computer /force /wait:60 | Out-Null; $exitCode=$LASTEXITCODE }
$rules = @(Get-NetFirewallRule -PolicyStore ActiveStore -Name 'LaSalle-Management-*' -ErrorAction SilentlyContinue |
Where-Object { $_.PolicyStoreSourceType -eq 'GroupPolicy' -and $_.Enabled -eq 'True' })
$applied = @(Get-CimInstance -Namespace root\RSOP\Computer -ClassName RSOP_GPO)
[pscustomobject]@{
Name=$env:COMPUTERNAME; Reachable=$true; SecureChannel=(Test-ComputerSecureChannel)
PolicyApplied=($applied.Name -contains 'La Salle - Workstation remote management')
RdpEnabled=((Get-ItemPropertyValue 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server' -Name fDenyTSConnections) -eq 0)
NLA=((Get-ItemPropertyValue 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp' -Name UserAuthentication) -eq 1)
WinRM=[string](Get-Service WinRM).Status; RdpService=[string](Get-Service TermService).Status
PolicyFirewallRules=$rules.Count; GpUpdateExit=$exitCode
}
} | Select-Object Name,Reachable,SecureChannel,PolicyApplied,RdpEnabled,NLA,WinRM,RdpService,PolicyFirewallRules,GpUpdateExit
} catch {
[pscustomobject]@{Name=$name;Reachable=$false;Error=$_.Exception.Message}
}
}
@@ -523,6 +523,7 @@ foreach ($requiredPath in @(
(Join-Path $scriptsRoot 'Enable-SguWorkstationRemoteAccess.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationAdministrators.ps1'),
(Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1'),
(Join-Path $scriptsRoot 'Install-SguDomainRemoteManagementPolicy.ps1'),
(Join-Path $scriptsRoot 'Set-SguDomainUserPolicies.ps1'),
(Join-Path $scriptsRoot 'Set-SguLaboratorioWallpaperPolicy.ps1'),
(Join-Path $scriptsRoot 'Enable-SguServerRemoteManagement.ps1'),
@@ -831,6 +832,8 @@ $collectorFqdn = "$env:COMPUTERNAME.$DomainName"
& (Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1') `
-TargetOuDn $laboratoryOuDn `
-DomainController $env:COMPUTERNAME | Out-Null
& (Join-Path $scriptsRoot 'Install-SguDomainRemoteManagementPolicy.ps1') `
-DomainController $env:COMPUTERNAME | Out-Null
& (Join-Path $scriptsRoot 'Install-SguDomainMonitoring.ps1') `
-CollectorFqdn $collectorFqdn `
-ComputerOuDn $laboratoryOuDn `
@@ -0,0 +1,195 @@
[CmdletBinding()]
param(
[string]$GpoName = 'La Salle - Workstation remote management',
[string]$DomainController = $env:COMPUTERNAME,
[string[]]$ManagementAddresses = @('LocalSubnet'),
[string]$LocalDnsServer = '',
[string]$FallbackDnsServer = ''
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
Import-Module GroupPolicy
Import-Module NetSecurity
$domain = Get-ADDomain -Server $DomainController
$dnsRoot = $domain.DNSRoot
$domainDn = $domain.DistinguishedName
$gpo = Get-GPO -Name $GpoName -Domain $dnsRoot -Server $DomainController -ErrorAction SilentlyContinue
$changes = [Collections.Generic.List[string]]::new()
if (-not $gpo) {
$gpo = New-GPO -Name $GpoName -Domain $dnsRoot -Server $DomainController
$changes.Add('Created GPO')
}
if ($gpo.GpoStatus -ne 'UserSettingsDisabled') {
$gpo.GpoStatus = [Microsoft.GroupPolicy.GpoStatus]::UserSettingsDisabled
$changes.Add('Computer settings only')
}
$policyDn = "CN={$($gpo.Id)},CN=Policies,CN=System,$domainDn"
$policyRoot = Join-Path $env:WINDIR "SYSVOL\domain\Policies\{$($gpo.Id)}"
# Domain-root inheritance includes newly joined computers in CN=Computers.
# The WMI filter limits the policy to workstation OSes (Windows 10 and 11).
$filterName = 'La Salle - Windows workstations'
$filter = Get-ADObject -Server $DomainController -SearchBase "CN=SOM,CN=WMIPolicy,CN=System,$domainDn" `
-LDAPFilter '(objectClass=msWMI-Som)' -Properties msWMI-Name,msWMI-ID,msWMI-Parm2 |
Where-Object { $_.'msWMI-Name' -eq $filterName }
$query = 'SELECT * FROM Win32_OperatingSystem WHERE ProductType = 1'
$encodedQuery = "1;3;10;$($query.Length);WQL;root\CIMv2;$query;"
if (@($filter).Count -gt 1) { throw 'Duplicate workstation WMI filters; inspect before editing.' }
if (-not $filter) {
$filterId = '{' + [guid]::NewGuid().ToString().ToUpperInvariant() + '}'
$timestamp = (Get-Date).ToUniversalTime().ToString('yyyyMMddHHmmss.ffffff-000')
$filter = New-ADObject -Server $DomainController -Name $filterId -Type msWMI-Som `
-Path "CN=SOM,CN=WMIPolicy,CN=System,$domainDn" -OtherAttributes @{
'msWMI-Name' = $filterName; 'msWMI-ID' = $filterId
'msWMI-Parm1' = 'Domain workstation management; excludes servers and DCs.'
'msWMI-Parm2' = $encodedQuery; 'msWMI-Author' = 'Domain administrators'
'msWMI-CreationDate' = $timestamp; 'msWMI-ChangeDate' = $timestamp
} -PassThru
$filter = Get-ADObject $filter.DistinguishedName -Server $DomainController -Properties msWMI-ID
$changes.Add('Created workstation filter')
} elseif ($filter.'msWMI-Parm2' -ne $encodedQuery) {
throw 'Existing workstation filter has a different query; inspect before changing it.'
}
$filterReference = "[$dnsRoot;$($filter.'msWMI-ID');0]"
$policy = Get-ADObject $policyDn -Server $DomainController -Properties gPCWQLFilter
if ($policy.gPCWQLFilter -ne $filterReference) {
Set-ADObject $policyDn -Server $DomainController -Replace @{gPCWQLFilter=$filterReference}
$changes.Add('Linked workstation filter')
}
$registry = @(
@{Key='HKLM\Software\Policies\Microsoft\Windows NT\Terminal Services'; Name='fDenyTSConnections'; Type='DWord'; Value=0},
@{Key='HKLM\Software\Policies\Microsoft\Windows NT\Terminal Services'; Name='UserAuthentication'; Type='DWord'; Value=1},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WinRM\Service'; Name='AllowAutoConfig'; Type='DWord'; Value=1},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WinRM\Service'; Name='IPv4Filter'; Type='String'; Value='*'},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WinRM\Service'; Name='IPv6Filter'; Type='String'; Value='*'},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WinRM\Service\WinRS'; Name='AllowRemoteShellAccess'; Type='DWord'; Value=1}
)
foreach ($setting in $registry) {
$current = Get-GPRegistryValue -Name $GpoName -Domain $dnsRoot -Server $DomainController `
-Key $setting.Key -ValueName $setting.Name -ErrorAction SilentlyContinue
if (-not $current -or [string]$current.Value -ne [string]$setting.Value -or [string]$current.Type -ne $setting.Type) {
Set-GPRegistryValue -Name $GpoName -Domain $dnsRoot -Server $DomainController `
-Key $setting.Key -ValueName $setting.Name -Type $setting.Type -Value $setting.Value | Out-Null
$changes.Add("Registry: $($setting.Name)")
}
}
# Firewall policy is enforced by the native firewall CSE, including gpupdate.
# RPC dynamic ports are restricted to their Windows service, not opened broadly.
$ruleDefinitions = @(
@{Name='WinRM'; Protocol='TCP'; Port='5985'; Service='WinRM'},
@{Name='RDP-TCP'; Protocol='TCP'; Port='3389'; Service='TermService'},
@{Name='RDP-UDP'; Protocol='UDP'; Port='3389'; Service='TermService'},
@{Name='RPC-Endpoint'; Protocol='TCP'; Port='RPCEPMap'; Service='RpcSs'},
@{Name='WMI'; Protocol='TCP'; Port='Any'; Service='winmgmt'},
@{Name='EventLog'; Protocol='TCP'; Port='RPC'; Service='EventLog'},
@{Name='Services'; Protocol='TCP'; Port='RPC'; Service='services.exe'; Program='%SystemRoot%\System32\services.exe'},
@{Name='Tasks'; Protocol='TCP'; Port='RPC'; Service='Schedule'},
@{Name='Firewall'; Protocol='TCP'; Port='RPC'; Service='MpsSvc'},
@{Name='Volumes'; Protocol='TCP'; Port='RPC'; Service='vds'},
@{Name='Performance'; Protocol='TCP'; Port='RPC'; Service='pla'},
@{Name='SMB'; Protocol='TCP'; Port='445'; Service='LanmanServer'; Program='System'}
)
$session = Open-NetGPO -PolicyStore "$dnsRoot\$GpoName" -DomainController $DomainController
$firewallChanged = $false
foreach ($definition in $ruleDefinitions) {
$name = 'LaSalle-Management-' + $definition.Name
$program = '%SystemRoot%\System32\svchost.exe'
$service = $definition.Service
if ($definition.Program) { $program = $definition.Program }
if ($service -eq 'services.exe') { $service = 'Any' }
$existing = Get-NetFirewallRule -GPOSession $session -Name $name -ErrorAction SilentlyContinue
$valid = $false
if ($existing) {
$port = $existing | Get-NetFirewallPortFilter
$address = $existing | Get-NetFirewallAddressFilter
$application = $existing | Get-NetFirewallApplicationFilter
$svc = $existing | Get-NetFirewallServiceFilter
$valid = $existing.Enabled -eq 'True' -and $existing.Profile -eq 'Any' -and
$existing.Action -eq 'Allow' -and $existing.Direction -eq 'Inbound' -and
[string]$port.Protocol -eq $definition.Protocol -and [string]$port.LocalPort -eq $definition.Port -and
$application.Program -eq $program -and $svc.Service -eq $service -and
-not @(Compare-Object @($address.RemoteAddress) $ManagementAddresses).Count
}
if ($valid) { continue }
if ($existing) { $existing | Remove-NetFirewallRule }
New-NetFirewallRule -GPOSession $session -Name $name -DisplayName $name `
-Group 'La Salle remote management' -Enabled True -Direction Inbound -Action Allow `
-Profile Any -Protocol $definition.Protocol -LocalPort $definition.Port `
-Program $program -Service $service -RemoteAddress $ManagementAddresses | Out-Null
$firewallChanged = $true
$changes.Add("Firewall: $name")
}
if ($firewallChanged) { Save-NetGPO -GPOSession $session }
function Set-PolicyFile([string]$RelativePath, [string]$Content) {
$path = Join-Path $policyRoot $RelativePath
if ((Test-Path -LiteralPath $path) -and [IO.File]::ReadAllText($path) -eq $Content) { return $false }
New-Item -ItemType Directory -Path (Split-Path $path) -Force | Out-Null
[IO.File]::WriteAllText($path, $Content, [Text.UTF8Encoding]::new($false))
$changes.Add("File: $RelativePath")
return $true
}
$servicesXml = @'
<?xml version="1.0" encoding="utf-8"?>
<NTServices clsid="{2CFB484A-4E96-4b5d-A0B6-093D2F91E6AE}">
<NTService clsid="{AB6F0B67-341F-4e51-92F9-005FBFBA1A43}" name="WinRM" image="2" uid="{49771BD6-DA5C-4138-9C1A-E9CAAC7194F1}"><Properties startupType="AUTOMATIC" serviceName="WinRM" serviceAction="RESTART_IF_REQUIRED" timeout="30" /></NTService>
<NTService clsid="{AB6F0B67-341F-4e51-92F9-005FBFBA1A43}" name="TermService" image="2" uid="{05CF2CCF-006A-4829-92CD-9FF53867942E}"><Properties startupType="AUTOMATIC" serviceName="TermService" serviceAction="RESTART_IF_REQUIRED" timeout="30" /></NTService>
<NTService clsid="{AB6F0B67-341F-4e51-92F9-005FBFBA1A43}" name="RemoteRegistry" image="2" uid="{B09673B4-1054-4D2D-A29D-4203E2E7B60C}"><Properties startupType="MANUAL" serviceName="RemoteRegistry" serviceAction="NOCHANGE" timeout="30" /></NTService>
</NTServices>
'@
$fileChanged = Set-PolicyFile 'Machine\Preferences\Services\Services.xml' $servicesXml
$registryXml = @'
<?xml version="1.0" encoding="utf-8"?>
<RegistrySettings clsid="{A3CCFC41-DFDB-43a5-8D26-0FE8B954DA51}">
<Registry clsid="{9CD4B2F4-923D-47f5-A062-E897DD1DAD50}" name="fDenyTSConnections" status="fDenyTSConnections" image="2" uid="{65FCC5F4-38E4-4A55-A8E0-B41BF7F79CDD}"><Properties action="U" hive="HKEY_LOCAL_MACHINE" key="SYSTEM\CurrentControlSet\Control\Terminal Server" name="fDenyTSConnections" type="REG_DWORD" value="00000000" /></Registry>
<Registry clsid="{9CD4B2F4-923D-47f5-A062-E897DD1DAD50}" name="UserAuthentication" status="UserAuthentication" image="2" uid="{7F6126E4-534C-4AF6-8D9C-CB8642D1607C}"><Properties action="U" hive="HKEY_LOCAL_MACHINE" key="SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" name="UserAuthentication" type="REG_DWORD" value="00000001" /></Registry>
</RegistrySettings>
'@
$fileChanged = (Set-PolicyFile 'Machine\Preferences\Registry\Registry.xml' $registryXml) -or $fileChanged
$helperName = 'Enable-SguWorkstationRemoteAccess.ps1'
$helper = [IO.File]::ReadAllText((Join-Path $PSScriptRoot $helperName))
$fileChanged = (Set-PolicyFile "Machine\Scripts\Startup\$helperName" $helper) -or $fileChanged
$parameters = "-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"\\$dnsRoot\SYSVOL\$dnsRoot\Policies\{$($gpo.Id)}\Machine\Scripts\Startup\$helperName`""
if ($LocalDnsServer) {
[Net.IPAddress]::Parse($LocalDnsServer) | Out-Null
$parameters += " -LocalDnsServer $LocalDnsServer"
if ($FallbackDnsServer) {
[Net.IPAddress]::Parse($FallbackDnsServer) | Out-Null
$parameters += " -FallbackDnsServer $FallbackDnsServer"
}
} elseif ($FallbackDnsServer) {
throw 'FallbackDnsServer requires a LocalDnsServer.'
}
$scriptsIni = "[Startup]`r`n0CmdLine=powershell.exe`r`n0Parameters=$parameters`r`n"
$fileChanged = (Set-PolicyFile 'Machine\Scripts\scripts.ini' $scriptsIni) -or $fileChanged
$policy = Get-ADObject $policyDn -Server $DomainController -Properties gPCMachineExtensionNames,versionNumber
$extensions = [string]$policy.gPCMachineExtensionNames
foreach ($extension in @(
'[{B087BE9D-ED37-454F-AF9C-04291E351182}{BEE07A6A-EC9F-4659-B8C9-0B193F6C7FE2}]',
'[{91FBB303-0CD5-4055-BF42-E512A681B325}{CC5746A9-9B74-4BE5-AE2E-64379C86E0E4}]',
'[{42B5FAAE-6536-11D2-AE5A-0000F87571E3}{40B6664F-4972-11D1-A7CA-0000F87571E3}]'
)) {
if (-not $extensions.Contains($extension)) { $extensions += $extension; $fileChanged = $true }
}
if ($fileChanged) {
# Preserve the user-version word. Sort CSEs as required by Group Policy.
$extensions = (@([regex]::Matches($extensions, '\[[^\]]+\]') | ForEach-Object Value | Sort-Object -Unique) -join '')
$oldVersion = [long]$policy.versionNumber
$version = ($oldVersion -band 0xFFFF0000L) -bor (($oldVersion + 1) -band 0xFFFFL)
Set-ADObject $policyDn -Server $DomainController -Replace @{gPCMachineExtensionNames=$extensions; versionNumber=[int]$version}
[IO.File]::WriteAllText((Join-Path $policyRoot 'GPT.INI'), "[General]`r`nVersion=$version`r`n", [Text.UTF8Encoding]::new($false))
}
$links = @(Get-GPInheritance -Target $domainDn -Domain $dnsRoot -Server $DomainController).GpoLinks
$link = $links | Where-Object { $_.GpoId -eq $gpo.Id }
if (-not $link) {
New-GPLink -Guid $gpo.Id -Target $domainDn -Domain $dnsRoot -Server $DomainController -LinkEnabled Yes -Enforced Yes | Out-Null
$changes.Add('Linked at domain root')
} elseif (-not $link.Enabled -or -not $link.Enforced) {
Set-GPLink -Guid $gpo.Id -Target $domainDn -Domain $dnsRoot -Server $DomainController -LinkEnabled Yes -Enforced Yes | Out-Null
$changes.Add('Enabled enforced domain link')
}
[pscustomobject]@{Gpo=$GpoName; Id=[string]$gpo.Id; Domain=$dnsRoot; Changed=($changes.Count -gt 0); Changes=@($changes.ToArray())}
+3
View File
@@ -216,6 +216,9 @@ $serverScripts = @(
'Get-SguBrokerLog.ps1',
'Install-SguDomainMonitoring.ps1',
'Install-SguWorkstationRemoteAccessPolicy.ps1',
'Install-SguDomainRemoteManagementPolicy.ps1',
'Sync-SguWacDomainConnections.ps1',
'Get-SguWorkstationRemoteManagementStatus.ps1',
'Publish-SguFsLogixClientDeployment.ps1',
'Install-SguRustDeskClient.ps1',
'Install-SguRustDeskLinuxEnrollment.ps1',
+92
View File
@@ -0,0 +1,92 @@
[CmdletBinding()]
param(
[Parameter(Mandatory)][uri]$Endpoint,
[Parameter(Mandatory)][PSCredential]$Credential,
[string]$DomainController = $env:COMPUTERNAME,
[string[]]$VerifyNodes = @()
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
Import-Module Microsoft.PowerShell.Utility
$base = $Endpoint.AbsoluteUri.TrimEnd('/')
$webSession = [Microsoft.PowerShell.Commands.WebRequestSession]::new()
# WAC v2's native form-login protocol, including CSRF and RSA-OAEP-SHA256.
# This signs in with the supplied existing account; no authentication settings
# or stored passwords are changed. Cookies remain only in this process.
try {
$page = Invoke-WebRequest -Uri "$base/" -WebSession $webSession -UseBasicParsing
$html = $page.Content
} catch {
if ([int]$_.Exception.Response.StatusCode -ne 403) { throw }
$reader = [IO.StreamReader]::new($_.Exception.Response.GetResponseStream())
try { $html = $reader.ReadToEnd() } finally { $reader.Dispose() }
}
$csrfMatch = [regex]::Match($html, 'var csrf\s*=\s*"([^"]+)"')
if (-not $csrfMatch.Success) {
$input = [regex]::Match($html, '<input\b[^>]*\bid="csrf"[^>]*>').Value
$csrfMatch = [regex]::Match($input, '\bvalue="([^"]+)"')
}
if (-not $csrfMatch.Success) { throw 'WAC form-login page did not supply a CSRF token.' }
$csrf = [Net.WebUtility]::HtmlDecode($csrfMatch.Groups[1].Value)
$key = Invoke-RestMethod -Uri "$base/api/user/key" -Method Post -WebSession $webSession `
-ContentType 'application/json' -Body (@{csrf=$csrf} | ConvertTo-Json -Compress)
function ConvertFrom-Base64Url([string]$Text) {
$text = $Text.Replace('-', '+').Replace('_', '/')
while ($text.Length % 4) { $text += '=' }
return [Convert]::FromBase64String($text)
}
$rsa = [Security.Cryptography.RSACng]::new()
try {
$parameters = [Security.Cryptography.RSAParameters]::new()
$parameters.Modulus = ConvertFrom-Base64Url $key.jwk.n
$parameters.Exponent = ConvertFrom-Base64Url $key.jwk.e
$rsa.ImportParameters($parameters)
$plainPassword = ([Net.NetworkCredential]::new('', $Credential.Password)).Password
$data = @{username=$Credential.UserName; password=$plainPassword; csrf=$csrf} | ConvertTo-Json -Compress
$bytes = [Text.Encoding]::UTF8.GetBytes($data)
$packet = [Convert]::ToBase64String($rsa.Encrypt($bytes, [Security.Cryptography.RSAEncryptionPadding]::OaepSHA256))
$plainPassword = $null; $data = $null
[Array]::Clear($bytes, 0, $bytes.Length)
} finally { $rsa.Dispose() }
$login = Invoke-WebRequest -Uri "$base/api/user/login" -Method Post -WebSession $webSession `
-UseBasicParsing -ContentType 'application/json' -Body (@{packet=$packet;csrf=$csrf} | ConvertTo-Json -Compress)
if ($login.StatusCode -ne 200) { throw 'WAC rejected the supplied account.' }
$existing = Invoke-RestMethod -Uri "$base/api/connections" -WebSession $webSession
$computers = @(Get-ADComputer -Server $DomainController -Filter 'Enabled -eq $true' -Properties OperatingSystem,DNSHostName |
Where-Object { $_.DNSHostName -and $_.OperatingSystem -like 'Windows*' })
$pending = @(
foreach ($computer in $computers) {
$type = 'msft.sme.connection-type.windows-client'
if ($computer.OperatingSystem -like '*Server*') { $type = 'msft.sme.connection-type.server' }
$name = $computer.DNSHostName.ToLowerInvariant()
$id = "$type!$name!global"
$tags = @('Dominio', 'La Salle')
$current = $existing.value | Where-Object { $_.id -eq $id -or $_.name -eq $id -or
($_.properties.name -ieq $name -and $_.properties.type -eq $type -and $_.properties.groupId -eq 'global') }
if ($current) { continue }
[pscustomobject]@{name=$name;type=$type;tags=$tags;groupId='global';id=$id}
}
)
if ($pending.Count) {
$response = Invoke-RestMethod -Uri "$base/api/connections" -Method Put -WebSession $webSession `
-ContentType 'application/json' -Body (ConvertTo-Json -InputObject @($pending) -Depth 4)
if ($response.errors) { throw ($response.errors | ConvertTo-Json -Depth 4) }
}
$verified = Invoke-RestMethod -Uri "$base/api/connections" -WebSession $webSession
$shared = @($verified.value | Where-Object { $_.properties.groupId -eq 'global' })
$missing = @($computers | Where-Object {
$shared.properties.name -inotcontains $_.DNSHostName
})
if ($missing.Count) { throw "WAC inventory verification failed: $($missing.Name -join ', ')" }
[pscustomobject]@{DomainComputers=$computers.Count;Added=$pending.Count;SharedConnections=$shared.Count;Missing=$missing.Count}
foreach ($node in $VerifyNodes) {
if ($node -notmatch '^[A-Za-z0-9.-]+$') { throw 'Invalid verification hostname.' }
$uri = "$base/api/services/WinREST/CIM/nodes/$node/namespaces/root.cimv2/classes/Win32_OperatingSystem/instances"
$response = Invoke-WebRequest -Uri $uri -WebSession $webSession -UseBasicParsing
$result = $response.Content | ConvertFrom-Json
$instances = @($result.value | Where-Object { $null -ne $_ })
if (-not $instances.Count) { throw "WAC returned no OS instances for $node." }
[pscustomobject]@{Node=$node;Status=$response.StatusCode;Instances=$instances.Count;ReturnedData=$true}
}