Compare commits

...
3 Commits
21 changed files with 639 additions and 58 deletions

No files matched your search

+10 -5
View File
@@ -68,15 +68,20 @@ that same password directly to ADSI `SetPassword`. This is an idempotent UPSERT
performed on every successful sign-in, so the next sign-in after an institutional
password change updates AD before Windows validates the interactive logon. If
SGU explicitly rejects the credential, the provider stops without trying AD.
If SGO accepts it but AD synchronization fails, the provider reports that
failure without trying a stale AD verifier. Only a genuine broker/SGO outage
If SGU accepts it but AD synchronization fails, the provider reports that
failure without trying a stale AD verifier. Only a genuine broker/SGU outage
uses the documented Windows cached-domain-credential fallback, for an existing
account. A matching username pattern alone never provisions an account.
The domain bootstrap creates a fine-grained password policy for the three SGU
role security groups. It allows the broker to record the exact password SGO
accepted, even when the normal domain complexity policy would reject it. It
does not relax password requirements for other domain accounts.
role security groups. It allows the broker to record the exact password SGU
accepted even when the normal domain complexity policy would reject it, while
keeping reversible password storage disabled. The domain default remains
unchanged. Bootstrap clears the per-user reversible-storage flag for members of
the three SGU groups, and the broker clears it before every password
synchronization. Existing reversibly stored passwords remain so until the next
password reset; successful Acceso SGU sign-in synchronizes the password using
the disabled setting.
Before an account becomes usable, the broker applies explicit deny ACEs for the
Active Directory `Change Password` extended right to SELF and Everyone. Users
+6 -6
View File
@@ -1,19 +1,19 @@
# v0.6.19 — SGO password authority
# v0.6.19 — SGU password authority
- Add a fine-grained Active Directory password policy scoped to the three
`SGU-*` role groups. A password accepted by SGO is stored unchanged in AD,
`SGU-*` role groups. A password accepted by SGU is stored unchanged in AD,
including short passwords that the default domain complexity policy rejects.
Other domain accounts keep their existing policy.
- Apply and verify this policy during server bootstrap. Existing SGU accounts
receive it through their role-group membership.
- Stop institutional login immediately when SGO explicitly rejects a password.
When SGO accepts it but AD synchronization fails, show a distinct error
- Stop institutional login immediately when SGU explicitly rejects a password.
When SGU accepts it but AD synchronization fails, show a distinct error
instead of trying an older AD password.
- Preserve the documented cached-domain fallback only while the broker or SGO
- Preserve the documented cached-domain fallback only while the broker or SGU
is genuinely unavailable.
Operational validation: on the domain controller, disposable users in each of
`SGU-Alumnos`, `SGU-Administrativos`, and `SGU-Docentes` accepted a three-character
password and were removed after the test. The three originally reported
accounts still require a real SGO sign-in to finish AD provisioning; no student
accounts still require a real SGU sign-in to finish AD provisioning; no student
password was requested or stored for testing.
+20
View File
@@ -0,0 +1,20 @@
# v0.6.20 — SGU-scoped reversible password storage
- Enable reversible password storage only for members of the three SGU role
groups (`SGU-Alumnos`, `SGU-Administrativos`, and `SGU-Docentes`). The
domain-wide default password policy remains unchanged.
- Before synchronizing a valid Acceso SGU login, the broker enables the
per-account AD flag and then writes the exact SGU-accepted password. Existing
role-group members are repaired by server bootstrap and the password-policy
deployment script.
- Add structured broker event 1306 when the per-account setting is enabled.
- Document that reversible storage allows a privileged directory-data reader to
recover the original password, and that existing passwords are rewritten only
after their next successful SGU password synchronization.
- Correct references that called the institutional system “SGO”; the product is
SGU.
The setting is intentionally limited to the SGU-managed role groups. Do not
apply it to unrelated domain users. Existing SGU accounts need a successful
Acceso SGU sign-in (or another authorized password reset) before their currently
stored password is rewritten using reversible encryption.
+15
View File
@@ -0,0 +1,15 @@
# v0.6.21 — Disable reversible password storage for SGU accounts
- Set `ReversibleEncryptionEnabled` to false in the fine-grained policy scoped
to `SGU-Alumnos`, `SGU-Administrativos`, and `SGU-Docentes`.
- Clear the per-account reversible-encryption flag for existing members of those
role groups, and make bootstrap keep the flag disabled.
- Update the Auth Broker to clear the flag before synchronizing any password
accepted by SGU, so future and existing managed accounts stay on one-way
password storage.
- Add broker event 1307 for an account whose reversible-storage flag is cleared.
The default domain policy remains unchanged and disabled. Password values that
were already stored reversibly are not transformed by changing these settings;
they are replaced using one-way storage when SGU next resets the password. A
successful Acceso SGU sign-in performs that synchronization.
+14 -9
View File
@@ -22,10 +22,15 @@ the same source list. RDP uses a separate allowlist. See
applies only to the global security groups `SGU-Alumnos`,
`SGU-Administrativos`, and `SGU-Docentes`. It disables AD complexity,
history, and password age requirements and permits passwords from one
character onward so a password accepted by SGO is never altered or rejected
by AD. The default domain password policy remains unchanged. The group is
assigned before `SetPassword` for newly created users. Bootstrap reapplies
the policy via `Set-SguInstitutionalPasswordPolicy.ps1`.
character onward so passwords accepted by SGU can be recorded unchanged by AD.
Reversible storage is disabled in this fine-grained policy and in each SGU
account. The default domain password policy remains unchanged for non-SGU
accounts. Bootstrap repairs existing role-group members, and the broker clears
the per-user reversible-storage flag before every `SetPassword`.
- Disabling reversible storage does not rewrite password data already stored in
reversible form. Those existing values remain until each password is reset;
the broker synchronizes the current SGU password on the next successful
Acceso SGU sign-in, at which point AD stores it without reversible encryption.
- Managed `Usuarios-SGU` accounts deny the SELF and Everyone `Change Password`
extended right. Only an administrator or the broker through the separate
`Reset Password` right can replace the AD password.
@@ -98,21 +103,21 @@ Use an enterprise CA with revocation checking in production.
The provider distinguishes an SGU rejection from unavailable infrastructure:
- `400`/`401`: do not create or update the account and do not submit a Windows
credential. An explicit SGO rejection is authoritative, including when an
credential. An explicit SGU rejection is authoritative, including when an
older AD password still exists.
- `DIRECTORY_SYNCHRONIZATION_FAILED`: SGO accepted the password but AD did not
- `DIRECTORY_SYNCHRONIZATION_FAILED`: SGU accepted the password but AD did not
record it. Show a specific error and do not attempt Windows logon against a
potentially stale AD verifier.
- timeout, TLS/connectivity error, `429`, or `5xx`: submit the unchanged
credential to Windows only for a genuine broker/SGO outage. Windows must still
credential to Windows only for a genuine broker/SGU outage. Windows must still
validate it against AD or its cached domain verifier, so this does not grant
access without a domain credential. This continuity path can accept a
last-known AD password while SGO is unreachable; decide explicitly whether
last-known AD password while SGU is unreachable; decide explicitly whether
that availability trade-off is appropriate for each deployment.
- usernames that do not match the institutional key format go directly to
Windows and are never sent to SGU or provisioned by the broker.
Allowing an SGO-accepted three-character password also allows that short
Allowing an SGU-accepted three-character password also allows that short
password at the native AD logon surface. Broker rate limiting does not protect
direct AD authentication; domain network exposure and monitoring therefore
remain essential. The policy cannot make a weak upstream password strong.
+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
+21 -2
View File
@@ -202,15 +202,33 @@ if ($RemoteDesktopGroupDn) {
}
$managedUsersPasswordChangeCorrected = 0
$managedUsersReversibleEncryptionDisabled = 0
$sguRoleGroupDns = @($ProfessorGroupDn, $StudentGroupDn, $AdministrativeGroupDn)
$sguRoleUserDns = [Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
foreach ($roleGroupDn in $sguRoleGroupDns) {
foreach ($member in Get-ADGroupMember -Identity $roleGroupDn -Recursive `
-Server $LdapHost -ErrorAction Stop) {
if ($member.objectClass -eq 'user') {
[void]$sguRoleUserDns.Add($member.DistinguishedName)
}
}
}
if ($PSCmdlet.ShouldProcess($usersOuDn, 'Deny direct password changes for every managed SGU user')) {
$managedUsers = @(Get-ADUser -Filter * -SearchBase $usersOuDn -SearchScope Subtree `
-Properties CannotChangePassword -Server $LdapHost -ErrorAction Stop)
-Properties CannotChangePassword,AllowReversiblePasswordEncryption `
-Server $LdapHost -ErrorAction Stop)
foreach ($managedUser in $managedUsers) {
if (-not $managedUser.CannotChangePassword) {
Set-ADAccountControl -Identity $managedUser.DistinguishedName `
-CannotChangePassword $true -Server $LdapHost -Confirm:$false
$managedUsersPasswordChangeCorrected++
}
if ($sguRoleUserDns.Contains($managedUser.DistinguishedName) -and
$managedUser.AllowReversiblePasswordEncryption) {
Set-ADAccountControl -Identity $managedUser.DistinguishedName `
-AllowReversiblePasswordEncryption $false -Server $LdapHost -Confirm:$false
$managedUsersReversibleEncryptionDisabled++
}
}
}
@@ -370,4 +388,5 @@ if ($PSCmdlet.ShouldProcess($installPath, 'Install the SGU Authentication Broker
Get-Service -Name $serviceName | Select-Object Name, Status, StartType,
@{ Name = 'EventLog'; Expression = { $brokerEventLogName } },
@{ Name = 'ExistingUsersPasswordChangeDenied'; Expression = { $managedUsersPasswordChangeCorrected } }
@{ Name = 'ExistingUsersPasswordChangeDenied'; Expression = { $managedUsersPasswordChangeCorrected } },
@{ Name = 'ExistingSguRoleUsersReversibleEncryptionDisabled'; Expression = { $managedUsersReversibleEncryptionDisabled } }
+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]
+2
View File
@@ -37,6 +37,8 @@ $eventNames = @{
1303 = 'DirectoryRoleGroupMembershipAdded'
1304 = 'DirectoryPasswordChangeDenied'
1305 = 'DirectoryPhotoFailure'
1306 = 'DirectoryReversiblePasswordEncryptionEnabled'
1307 = 'DirectoryReversiblePasswordEncryptionDisabled'
}
# Keep these reads unfiltered. Besides making archived and current logs behave
@@ -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 `
@@ -1,12 +1,12 @@
[CmdletBinding(SupportsShouldProcess)]
param(
[string]$Version = '0.6.19',
[string]$Version = '0.6.21',
[ValidatePattern('^https://')]
[string]$ClientPackageUri = 'https://gitea.lci.ulsa.mx/alexrg/SGU-CredentialProvider/releases/download/v0.6.19/sgu-windows-client-bootstrap-0.6.19.zip',
[string]$ClientPackageUri = 'https://gitea.lci.ulsa.mx/alexrg/SGU-CredentialProvider/releases/download/v0.6.21/sgu-windows-client-bootstrap-0.6.21.zip',
[ValidatePattern('^[0-9A-Fa-f]{64}$')]
[string]$ClientPackageSha256 = 'C1FA9C92BA941003FE54E9074973CF6630E30456B186C099E731EC5F54182F24',
[string]$ClientPackageSha256 = '59E2ECCB16A951D5A55D005325B734501868BFB2CFCFEF507A0FE8A1F829C21E',
[string]$GpoName = 'SGU - Credential Provider update',
@@ -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',
+32 -2
View File
@@ -18,7 +18,7 @@ if ($domain.DomainMode -lt 'Windows2012Domain') {
}
# AD's default password policy must remain intact for non-SGU accounts.
# The broker validates the exact password with SGO before resetting the AD
# The broker validates the exact password with SGU before resetting the AD
# verifier. These global security groups are assigned before SetPassword.
$groups = @(
"CN=SGU-Alumnos,OU=Alumnos,OU=Usuarios-SGU,$BaseDn",
@@ -51,7 +51,7 @@ $policy = Get-ADFineGrainedPasswordPolicy -Filter * -Server $DomainController |
if (-not $policy) {
if ($PSCmdlet.ShouldProcess($PolicyName, 'Create password policy limited to SGU role groups')) {
New-ADFineGrainedPasswordPolicy -Name $PolicyName @desired -Server $DomainController `
-Description 'SGO validates the exact institutional password; AD must not reject its complexity, length, history, or age.' `
-Description 'SGU validates the exact institutional password; reversible storage remains disabled and AD must not reject its complexity, length, history, or age.' `
-ProtectedFromAccidentalDeletion $true | Out-Null
}
}
@@ -80,6 +80,34 @@ foreach ($groupDn in $groups) {
}
}
# Existing SGU group members must have the per-account UAC bit cleared as well.
# The default domain policy stays unchanged, and users outside these three SGU
# groups are deliberately excluded.
$reversibleAccountsDisabled = 0
$usersOuDn = "OU=Usuarios-SGU,$BaseDn"
$managedUserDns = [Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
foreach ($groupDn in $groups) {
foreach ($member in Get-ADGroupMember -Identity $groupDn -Recursive `
-Server $DomainController -ErrorAction Stop) {
if ($member.objectClass -eq 'user') {
[void]$managedUserDns.Add($member.DistinguishedName)
}
}
}
foreach ($userDn in $managedUserDns) {
$user = Get-ADUser -Identity $userDn -Properties AllowReversiblePasswordEncryption `
-Server $DomainController -ErrorAction Stop
if (-not $user.DistinguishedName.EndsWith(",$usersOuDn", [StringComparison]::OrdinalIgnoreCase)) {
continue
}
if ($user.AllowReversiblePasswordEncryption -and
$PSCmdlet.ShouldProcess($user.SamAccountName, 'Disable reversible password storage for SGU account')) {
Set-ADAccountControl -Identity $user.DistinguishedName `
-AllowReversiblePasswordEncryption $false -Server $DomainController -Confirm:$false
$reversibleAccountsDisabled++
}
}
$policy = Get-ADFineGrainedPasswordPolicy -Identity $PolicyName -Properties AppliesTo `
-Server $DomainController -ErrorAction Stop
if (-not $WhatIfPreference) {
@@ -99,8 +127,10 @@ if (-not $WhatIfPreference) {
Name = $policy.Name
Precedence = $policy.Precedence
ComplexityEnabled = $policy.ComplexityEnabled
ReversibleEncryptionEnabled = $policy.ReversibleEncryptionEnabled
MinPasswordLength = $policy.MinPasswordLength
PasswordHistoryCount = $policy.PasswordHistoryCount
MaxPasswordAge = $policy.MaxPasswordAge
ExistingAccountFlagsDisabled = $reversibleAccountsDisabled
Subjects = @($policy.AppliesTo)
}
+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}
}
+2
View File
@@ -26,4 +26,6 @@ internal static class BrokerEventIds
internal static readonly EventId DirectoryRoleGroupMembershipAdded = new(1303, nameof(DirectoryRoleGroupMembershipAdded));
internal static readonly EventId DirectoryPasswordChangeDenied = new(1304, nameof(DirectoryPasswordChangeDenied));
internal static readonly EventId DirectoryPhotoFailure = new(1305, nameof(DirectoryPhotoFailure));
internal static readonly EventId DirectoryReversiblePasswordEncryptionEnabled = new(1306, nameof(DirectoryReversiblePasswordEncryptionEnabled));
internal static readonly EventId DirectoryReversiblePasswordEncryptionDisabled = new(1307, nameof(DirectoryReversiblePasswordEncryptionDisabled));
}
@@ -17,6 +17,7 @@ public sealed class ActiveDirectorySynchronizer(
private const int InfoAttributeMaximumLength = 1024;
private const int AccountDisabled = 0x0002;
private const int NormalAccount = 0x0200;
private const int ReversiblePasswordEncryptionAllowed = 0x0080;
private static readonly Guid ChangePasswordExtendedRight =
new("AB721A53-1E2F-11D0-9819-00AA0040529B");
private static readonly SecurityIdentifier EveryoneSid =
@@ -131,6 +132,10 @@ public sealed class ActiveDirectorySynchronizer(
// which ADSI SetPassword uses for each successful authentication.
EnsureCannotChangePassword(user, identity.UserName);
// Keep reversible storage disabled for SGU users. Clear the account
// flag before writing the password so this reset uses one-way storage.
EnsureReversiblePasswordEncryptionDisabled(user, identity.UserName);
// The exact institutional password received by the broker is passed to AD.
// It is not derived, transformed, written to disk, or included in logs.
user.Invoke("SetPassword", [password]);
@@ -175,6 +180,23 @@ public sealed class ActiveDirectorySynchronizer(
institutionalUser);
}
private void EnsureReversiblePasswordEncryptionDisabled(DirectoryEntry user, string institutionalUser)
{
object? rawFlags = user.Properties["userAccountControl"].Value;
int flags = rawFlags is null ? NormalAccount : Convert.ToInt32(rawFlags);
if ((flags & ReversiblePasswordEncryptionAllowed) == 0)
{
return;
}
user.Properties["userAccountControl"].Value = flags & ~ReversiblePasswordEncryptionAllowed;
user.CommitChanges();
logger.LogInformation(
BrokerEventIds.DirectoryReversiblePasswordEncryptionDisabled,
"Disabled reversible password storage for SGU-managed Active Directory user {InstitutionalUser}.",
institutionalUser);
}
internal static bool EnsureCannotChangePassword(ActiveDirectorySecurity security)
{
bool changed = false;
@@ -80,21 +80,21 @@ internal sealed class SguCredentialTile : CredentialTile3
return DomainCredential(decision.Domain!, decision.UserName!, securePassword);
}
// An explicit SGO rejection is authoritative even when an older AD
// An explicit SGU rejection is authoritative even when an older AD
// verifier for the same institutional key still exists.
if (decision.Kind == BrokerDecisionKind.InvalidCredentials)
{
return Failure("Usuario o contraseña incorrectos.");
}
// SGO accepted this password but AD could not record it. Windows
// SGU accepted this password but AD could not record it. Windows
// must not attempt a logon against a stale AD password.
if (decision.ErrorCode == "DIRECTORY_SYNCHRONIZATION_FAILED")
{
return Failure("La contraseña institucional fue aceptada, pero no se pudo preparar la cuenta en Active Directory. Intenta nuevamente o contacta a soporte.");
}
// Only a genuine broker/SGO outage permits the documented cached
// Only a genuine broker/SGU outage permits the documented cached
// domain-credential path for an existing account.
return DomainCredential(
domain,
+1 -1
View File
@@ -32,7 +32,7 @@ Describe 'SGU Auth Broker password authority' {
$userPolicy | Should Match '(?s)-ValueName \$disableChangePasswordValueName.*-Type DWord.*-Value 1'
}
It 'scopes exact SGO passwords to all three SGU role groups without changing the domain default' {
It 'scopes exact SGU passwords to all three SGU role groups without changing the domain default' {
foreach ($role in @('Alumnos', 'Administrativos', 'Docentes')) {
$passwordPolicy | Should Match "CN=SGU-$role,OU=$role,OU=Usuarios-SGU"
}
@@ -74,7 +74,7 @@ public sealed class BrokerClientTests
BrokerDecision decision = await client.AuthenticateAsync(
"AL250792",
"SGOAccepted",
"SGUAccepted",
TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind);