Compare commits

...
5 Commits
25 changed files with 1008 additions and 55 deletions

No files matched your search

+15 -3
View File
@@ -67,9 +67,21 @@ moves it to the mapped OU when required, sets `userPrincipalName`, and passes
that same password directly to ADSI `SetPassword`. This is an idempotent UPSERT 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 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 password change updates AD before Windows validates the interactive logon. If
SGU rejects the credential or is unavailable, the unchanged credentials go to SGU explicitly rejects the credential, the provider stops without trying AD.
Windows; only an existing AD account can then authenticate. A matching username If SGU accepts it but AD synchronization fails, the provider reports that
pattern alone never provisions an account. 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 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 Before an account becomes usable, the broker applies explicit deny ACEs for the
Active Directory `Change Password` extended right to SELF and Everyone. Users Active Directory `Change Password` extended right to SELF and Everyone. Users
+19
View File
@@ -0,0 +1,19 @@
# 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 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 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 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 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.
+29 -4
View File
@@ -18,6 +18,19 @@ the same source list. RDP uses a separate allowlist. See
`Marshal.ZeroFreeGlobalAllocUnicode`; managed references are released as soon `Marshal.ZeroFreeGlobalAllocUnicode`; managed references are released as soon
as each request completes. as each request completes.
- The broker uses the exact received value for both NTLM and AD `SetPassword`. - The broker uses the exact received value for both NTLM and AD `SetPassword`.
- The `SGU - Institutional password authority` fine-grained AD password policy
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 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` - Managed `Usuarios-SGU` accounts deny the SELF and Everyone `Change Password`
extended right. Only an administrator or the broker through the separate extended right. Only an administrator or the broker through the separate
`Reset Password` right can replace the AD password. `Reset Password` right can replace the AD password.
@@ -89,14 +102,26 @@ Use an enterprise CA with revocation checking in production.
The provider distinguishes an SGU rejection from unavailable infrastructure: The provider distinguishes an SGU rejection from unavailable infrastructure:
- `400`/`401`: do not create or update the account; submit the unchanged - `400`/`401`: do not create or update the account and do not submit a Windows
credential to Windows so an existing AD account can authenticate. credential. An explicit SGU rejection is authoritative, including when an
older AD password still exists.
- `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 - timeout, TLS/connectivity error, `429`, or `5xx`: submit the unchanged
credential to Windows. Windows must still validate it against AD or its cached credential to Windows only for a genuine broker/SGU outage. Windows must still
domain verifier, so this does not grant access without a domain credential. 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 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 - usernames that do not match the institutional key format go directly to
Windows and are never sent to SGU or provisioned by the broker. Windows and are never sent to SGU or provisioned by the broker.
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.
Redis is deliberately not used for password continuity. A second persistent Redis is deliberately not used for password continuity. A second persistent
password verifier duplicates attackable credential material, while a reversible password verifier duplicates attackable credential material, while a reversible
encrypted password becomes a credential vault. AD and Windows cached domain encrypted password becomes a credential vault. AD and Windows cached domain
+33
View File
@@ -0,0 +1,33 @@
# Administradores de las estaciones Windows
El grupo `LCI\Administrators` ubicado en `CN=Builtin` administra Active
Directory y los controladores de dominio. No convierte por sí solo a sus
miembros en administradores locales de las estaciones Windows. `Domain Admins`
sí suele estar en el grupo local `Administrators` de cada equipo unido al
dominio, pero agregar una cuenta a `Domain Admins` le daría mucho más alcance.
La GPO **SGU - Windows client experience**, vinculada a `OU=Laboratorio`,
ejecuta `Enable-SguWorkstationAdministrators.ps1` al inicio de cada equipo
Windows. El script consulta por LDAP a los usuarios (incluidos miembros
anidados) de `CN=Administrators,CN=Builtin,DC=lci,DC=lasalle,DC=mx` y agrega
sus SID de dominio al grupo `Administrators` local. No se aplica a los
controladores de dominio ni a los equipos Linux. Si el DC no responde, no
cambia la pertenencia local y lo reintenta en el siguiente arranque.
En siguientes arranques elimina solo los SID que esta política había agregado
y que ya no pertenecen al grupo de AD. Conserva los administradores locales
y los grupos agregados por otras políticas. Los cambios de membresía de AD
requieren reiniciar la estación y volver a iniciar sesión para obtener un
token de acceso nuevo; no se elevan las sesiones ya abiertas.
Comprobación en un cliente Windows, desde una consola elevada:
```powershell
gpresult /scope computer /r
Get-LocalGroupMember -SID 'S-1-5-32-544'
whoami /groups
```
Para actualizar la política en un equipo encendido, ejecute
`gpupdate /target:computer /force`, reinicie e inicie sesión nuevamente. La
concesión se limita a los equipos Windows que heredan la GPO del laboratorio.
+90 -21
View File
@@ -1,33 +1,102 @@
# Acceso remoto administrado por el dominio # Acceso remoto administrado por el dominio
`Install-SguWorkstationRemoteAccessPolicy.ps1` registra un script de inicio de `Install-SguDomainRemoteManagementPolicy.ps1` crea **La Salle - Workstation
equipo en la GPO existente **SGU - Windows client experience**, vinculada a remote management**, vinculada y exigida en la raíz del dominio. Su filtro WMI
`OU=Laboratorio`. El bootstrap del controlador lo instala después de crear esa `ProductType = 1` incluye estaciones Windows 10/11, incluso las nuevas cuentas
GPO. No crea una tarea programada en los clientes. en `CN=Computers`, y excluye servidores y controladores de dominio. Solo tiene
configuración de equipo. El bootstrap del controlador instala esta política.
Al arrancar una estación Windows 10 u 11 unida al dominio, el script activa La política usa extensiones nativas de Group Policy:
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.
Para aplicar una versión nueva a un cliente, ejecute PowerShell como - Plantillas administrativas: RDP permitido con NLA, listener WinRM y consola remota.
administrador y después reinicie: - 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).
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 la política a un cliente, ejecute PowerShell como administrador:
```powershell ```powershell
gpupdate /target:computer /force 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 La GPO debe figurar aplicada, el canal seguro devolver `True`, ambos servicios
inicio de equipo; `gpupdate` sin reiniciar no instala el proveedor nuevo. estar activos y las 12 reglas habilitadas con origen `GroupPolicy`.
Compruebe la aplicación con `gpresult /scope computer /r`, `Test-WSMan` y una `gpupdate` aplica registro, servicios y firewall sin cerrar la sesión. Reiniciar
conexión RDP desde la misma subred. Si el equipo no puede autenticarse ante una vez ejecuta además la preparación inicial del endpoint y DNS. La actualización
el controlador (`Test-ComputerSecureChannel` devuelve `False`), repare primero del proveedor de credenciales es otra GPO de inicio y necesita su propio reinicio.
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 Para revisar varias estaciones desde SGU-DC02, con una cuenta de administración
políticas. No elimine ni vuelva a crear su objeto de AD para forzar una GPO. 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 Desde un equipo administrador no unido al dominio, PowerShell Remoting por
HTTP requiere indicar `-Credential` y confiar explícitamente en el destino HTTP requiere indicar `-Credential` y confiar explícitamente en el destino
+21 -2
View File
@@ -202,15 +202,33 @@ if ($RemoteDesktopGroupDn) {
} }
$managedUsersPasswordChangeCorrected = 0 $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')) { if ($PSCmdlet.ShouldProcess($usersOuDn, 'Deny direct password changes for every managed SGU user')) {
$managedUsers = @(Get-ADUser -Filter * -SearchBase $usersOuDn -SearchScope Subtree ` $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) { foreach ($managedUser in $managedUsers) {
if (-not $managedUser.CannotChangePassword) { if (-not $managedUser.CannotChangePassword) {
Set-ADAccountControl -Identity $managedUser.DistinguishedName ` Set-ADAccountControl -Identity $managedUser.DistinguishedName `
-CannotChangePassword $true -Server $LdapHost -Confirm:$false -CannotChangePassword $true -Server $LdapHost -Confirm:$false
$managedUsersPasswordChangeCorrected++ $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, Get-Service -Name $serviceName | Select-Object Name, Status, StartType,
@{ Name = 'EventLog'; Expression = { $brokerEventLogName } }, @{ Name = 'EventLog'; Expression = { $brokerEventLogName } },
@{ Name = 'ExistingUsersPasswordChangeDenied'; Expression = { $managedUsersPasswordChangeCorrected } } @{ Name = 'ExistingUsersPasswordChangeDenied'; Expression = { $managedUsersPasswordChangeCorrected } },
@{ Name = 'ExistingSguRoleUsersReversibleEncryptionDisabled'; Expression = { $managedUsersReversibleEncryptionDisabled } }
@@ -0,0 +1,105 @@
[CmdletBinding()]
param()
$ErrorActionPreference = 'Stop'
$computer = Get-CimInstance Win32_ComputerSystem
if (-not $computer.PartOfDomain -or $computer.DomainRole -ge 4) { return }
# The domain's Builtin\Administrators group is not the local Administrators
# group on a member workstation, even though both have SID S-1-5-32-544.
# Resolve its *users* through LDAP, then grant their domain SIDs locally.
# The directory lookup must succeed before any local membership is changed.
$domainDn = 'DC=' + (($computer.Domain -split '\.') -join ',DC=')
$domainAdministratorsDn = "CN=Administrators,CN=Builtin,$domainDn"
$directoryRoot = [DirectoryServices.DirectoryEntry]::new("LDAP://$domainDn")
$searcher = [DirectoryServices.DirectorySearcher]::new($directoryRoot)
$searcher.Filter = "(&(objectCategory=person)(objectClass=user)(memberOf:1.2.840.113556.1.4.1941:=$domainAdministratorsDn))"
$searcher.PageSize = 500
$searcher.ClientTimeout = [TimeSpan]::FromSeconds(5)
$searcher.ServerTimeLimit = [TimeSpan]::FromSeconds(5)
[void]$searcher.PropertiesToLoad.Add('objectSid')
try {
$results = $searcher.FindAll()
try {
$desiredSids = @(
foreach ($result in $results) {
$sidBytes = [byte[]]$result.Properties['objectsid'][0]
if ($sidBytes.Length -gt 0) {
[Security.Principal.SecurityIdentifier]::new($sidBytes, 0).Value
}
}
) | Sort-Object -Unique
}
finally { $results.Dispose() }
}
catch {
Write-Warning "Cannot read domain Administrators; local membership was left unchanged: $($_.Exception.Message)"
return
}
finally {
$searcher.Dispose()
$directoryRoot.Dispose()
}
$localAdministratorsSid = [Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
$localAdministrators = Get-LocalGroup -SID $localAdministratorsSid
$group = [ADSI]("WinNT://$env:COMPUTERNAME/$($localAdministrators.Name),group")
function Get-MemberSids {
@($group.psbase.Invoke('Members') | ForEach-Object {
try {
$bytes = $_.GetType().InvokeMember('objectSid',
[Reflection.BindingFlags]::GetProperty, $null, $_, $null)
if ($bytes) {
[Security.Principal.SecurityIdentifier]::new([byte[]]$bytes, 0).Value
}
}
catch { }
})
}
$statePath = 'HKLM:\SOFTWARE\SGU\WorkstationAdministrators'
$managedSids = if (Test-Path -LiteralPath $statePath) {
@((Get-ItemProperty -LiteralPath $statePath -Name ManagedSids -ErrorAction SilentlyContinue).ManagedSids)
} else { @() }
$managedSids = @($managedSids | Where-Object { $_ -match '^S-1-5-21-' } | Sort-Object -Unique)
$presentSids = @(Get-MemberSids)
foreach ($sid in $desiredSids) {
if ($presentSids -notcontains $sid) {
Add-LocalGroupMember -Group $localAdministrators.Name -Member $sid
$presentSids += $sid
$managedSids += $sid
}
}
# Remove only entries previously added by this policy. Other local or domain
# administrators remain untouched if they have a separate authorization path.
foreach ($sid in @($managedSids | Where-Object { $desiredSids -notcontains $_ })) {
if ($presentSids -contains $sid) {
Remove-LocalGroupMember -Group $localAdministrators.Name -Member $sid
}
}
New-Item -Path $statePath -Force | Out-Null
$remainingManagedSids = @($managedSids |
Where-Object { $desiredSids -contains $_ } | Sort-Object -Unique)
if ($remainingManagedSids.Count -gt 0) {
$state = @{
Path = $statePath
Name = 'ManagedSids'
PropertyType = 'MultiString'
Value = $remainingManagedSids
Force = $true
}
New-ItemProperty @state | Out-Null
}
else {
Remove-ItemProperty -Path $statePath -Name ManagedSids -ErrorAction SilentlyContinue
}
$verifiedSids = @(Get-MemberSids)
$missingSids = @($desiredSids | Where-Object { $verifiedSids -notcontains $_ })
if ($missingSids.Count -gt 0) {
throw "Domain Administrators were not added to local Administrators: $($missingSids -join ', ')"
}
+67 -3
View File
@@ -1,9 +1,53 @@
[CmdletBinding()] [CmdletBinding()]
param([string]$RemoteDesktopPrincipal = 'LCI\SG-Laboratorio-Usuarios-RDP') param(
[string]$RemoteDesktopPrincipal = 'LCI\SG-Laboratorio-Usuarios-RDP',
[string]$LocalDnsServer = '',
[string]$FallbackDnsServer = ''
)
$ErrorActionPreference = 'Stop' $ErrorActionPreference = 'Stop'
$computer = Get-CimInstance Win32_ComputerSystem $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' $terminalKey = 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server'
$rdpKey = Join-Path $terminalKey 'WinStations\RDP-Tcp' $rdpKey = Join-Path $terminalKey 'WinStations\RDP-Tcp'
@@ -49,10 +93,30 @@ foreach ($rule in $rules) {
$listener = @(Get-ChildItem WSMan:\localhost\Listener -ErrorAction SilentlyContinue | $listener = @(Get-ChildItem WSMan:\localhost\Listener -ErrorAction SilentlyContinue |
Where-Object { $_.Keys -contains 'Transport=HTTP' }) Where-Object { $_.Keys -contains 'Transport=HTTP' })
$endpoint = Get-PSSessionConfiguration -Name Microsoft.PowerShell -ErrorAction SilentlyContinue $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 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. # The built-in local group has a stable SID across Windows display languages.
$groupSid = [Security.Principal.SecurityIdentifier]::new('S-1-5-32-555') $groupSid = [Security.Principal.SecurityIdentifier]::new('S-1-5-32-555')
$groupName = ($groupSid.Translate([Security.Principal.NTAccount]).Value -split '\\', 2)[1] $groupName = ($groupSid.Translate([Security.Principal.NTAccount]).Value -split '\\', 2)[1]
+2
View File
@@ -37,6 +37,8 @@ $eventNames = @{
1303 = 'DirectoryRoleGroupMembershipAdded' 1303 = 'DirectoryRoleGroupMembershipAdded'
1304 = 'DirectoryPasswordChangeDenied' 1304 = 'DirectoryPasswordChangeDenied'
1305 = 'DirectoryPhotoFailure' 1305 = 'DirectoryPhotoFailure'
1306 = 'DirectoryReversiblePasswordEncryptionEnabled'
1307 = 'DirectoryReversiblePasswordEncryptionDisabled'
} }
# Keep these reads unfiltered. Besides making archived and current logs behave # 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}
}
}
@@ -518,9 +518,12 @@ foreach ($requiredPath in @(
(Join-Path $scriptsRoot 'Deploy-AuthBroker.ps1'), (Join-Path $scriptsRoot 'Deploy-AuthBroker.ps1'),
(Join-Path $scriptsRoot 'New-LabCertificate.ps1'), (Join-Path $scriptsRoot 'New-LabCertificate.ps1'),
(Join-Path $scriptsRoot 'Set-LabBrokerDns.ps1'), (Join-Path $scriptsRoot 'Set-LabBrokerDns.ps1'),
(Join-Path $scriptsRoot 'Set-SguInstitutionalPasswordPolicy.ps1'),
(Join-Path $scriptsRoot 'Set-SguDomainComputerPolicies.ps1'), (Join-Path $scriptsRoot 'Set-SguDomainComputerPolicies.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationRemoteAccess.ps1'), (Join-Path $scriptsRoot 'Enable-SguWorkstationRemoteAccess.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationAdministrators.ps1'),
(Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1'), (Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1'),
(Join-Path $scriptsRoot 'Install-SguDomainRemoteManagementPolicy.ps1'),
(Join-Path $scriptsRoot 'Set-SguDomainUserPolicies.ps1'), (Join-Path $scriptsRoot 'Set-SguDomainUserPolicies.ps1'),
(Join-Path $scriptsRoot 'Set-SguLaboratorioWallpaperPolicy.ps1'), (Join-Path $scriptsRoot 'Set-SguLaboratorioWallpaperPolicy.ps1'),
(Join-Path $scriptsRoot 'Enable-SguServerRemoteManagement.ps1'), (Join-Path $scriptsRoot 'Enable-SguServerRemoteManagement.ps1'),
@@ -773,6 +776,9 @@ if (Test-Path -LiteralPath $brokerConfigurationPath -PathType Leaf) {
-CreateMissingOus ` -CreateMissingOus `
-DisableCertificateRevocationCheckForLab | Out-Null -DisableCertificateRevocationCheckForLab | Out-Null
& (Join-Path $scriptsRoot 'Set-SguInstitutionalPasswordPolicy.ps1') `
-BaseDn $baseDn -DomainController $adServer | Out-Null
# Remove stale A records registered by any non-domain/NAT adapter before its # Remove stale A records registered by any non-domain/NAT adapter before its
# dynamic DNS registration was disabled. # dynamic DNS registration was disabled.
$hostRecords = @(Get-DnsServerResourceRecord -ZoneName $DomainName ` $hostRecords = @(Get-DnsServerResourceRecord -ZoneName $DomainName `
@@ -826,6 +832,8 @@ $collectorFqdn = "$env:COMPUTERNAME.$DomainName"
& (Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1') ` & (Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1') `
-TargetOuDn $laboratoryOuDn ` -TargetOuDn $laboratoryOuDn `
-DomainController $env:COMPUTERNAME | Out-Null -DomainController $env:COMPUTERNAME | Out-Null
& (Join-Path $scriptsRoot 'Install-SguDomainRemoteManagementPolicy.ps1') `
-DomainController $env:COMPUTERNAME | Out-Null
& (Join-Path $scriptsRoot 'Install-SguDomainMonitoring.ps1') ` & (Join-Path $scriptsRoot 'Install-SguDomainMonitoring.ps1') `
-CollectorFqdn $collectorFqdn ` -CollectorFqdn $collectorFqdn `
-ComputerOuDn $laboratoryOuDn ` -ComputerOuDn $laboratoryOuDn `
@@ -1,12 +1,12 @@
[CmdletBinding(SupportsShouldProcess)] [CmdletBinding(SupportsShouldProcess)]
param( param(
[string]$Version = '0.6.16', [string]$Version = '0.6.21',
[ValidatePattern('^https://')] [ValidatePattern('^https://')]
[string]$ClientPackageUri = 'https://gitea.lci.ulsa.mx/alexrg/SGU-CredentialProvider/releases/download/v0.6.16/sgu-windows-client-bootstrap-0.6.16.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}$')] [ValidatePattern('^[0-9A-Fa-f]{64}$')]
[string]$ClientPackageSha256 = 'AFC40A87E83A6B27319792F575C384EBB175F42DCF670B7AB620A64C75ED499B', [string]$ClientPackageSha256 = '59E2ECCB16A951D5A55D005325B734501868BFB2CFCFEF507A0FE8A1F829C21E',
[string]$GpoName = 'SGU - Credential Provider update', [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())}
@@ -28,25 +28,48 @@ if (-not @($links | Where-Object { $_.DisplayName -eq $GpoName -and
throw "The existing GPO '$GpoName' must be linked and enabled on $TargetOuDn." throw "The existing GPO '$GpoName' must be linked and enabled on $TargetOuDn."
} }
# The existing machine GPO also manages the credential tile. The startup # The existing machine GPO also manages the credential tile. These startup
# script is a native Group Policy extension, not a scheduled client task. # scripts are a native Group Policy extension, not scheduled client tasks.
$scriptName = 'Enable-SguWorkstationRemoteAccess.ps1' $scriptNames = @(
$sourcePath = Join-Path $PSScriptRoot $scriptName 'Enable-SguWorkstationRemoteAccess.ps1',
'Enable-SguWorkstationAdministrators.ps1'
)
$startupRoot = Join-Path $env:WINDIR "SYSVOL\domain\Policies\{$($gpo.Id)}\Machine\Scripts" $startupRoot = Join-Path $env:WINDIR "SYSVOL\domain\Policies\{$($gpo.Id)}\Machine\Scripts"
$startupPath = Join-Path $startupRoot "Startup\$scriptName"
$scriptsIniPath = Join-Path $startupRoot 'scripts.ini' $scriptsIniPath = Join-Path $startupRoot 'scripts.ini'
$startupScripts = @(
foreach ($scriptName in $scriptNames) {
$sourcePath = Join-Path $PSScriptRoot $scriptName
$startupPath = Join-Path $startupRoot "Startup\$scriptName"
$source = [IO.File]::ReadAllText($sourcePath) $source = [IO.File]::ReadAllText($sourcePath)
$unc = "\\$domainName\SYSVOL\$domainName\Policies\{$($gpo.Id)}\Machine\Scripts\Startup\$scriptName" [pscustomobject]@{
$ini = "[Startup]`r`n0CmdLine=powershell.exe`r`n0Parameters=-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$unc`"`r`n" Name = $scriptName
$scriptChanged = -not (Test-Path -LiteralPath $startupPath) -or Path = $startupPath
Source = $source
Changed = -not (Test-Path -LiteralPath $startupPath) -or
[IO.File]::ReadAllText($startupPath) -cne $source [IO.File]::ReadAllText($startupPath) -cne $source
}
}
)
$iniLines = @('[Startup]')
for ($index = 0; $index -lt $scriptNames.Count; $index++) {
$unc = "\\$domainName\SYSVOL\$domainName\Policies\{$($gpo.Id)}\Machine\Scripts\Startup\$($scriptNames[$index])"
$iniLines += "${index}CmdLine=powershell.exe"
$iniLines += "${index}Parameters=-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$unc`""
}
$ini = ($iniLines -join "`r`n") + "`r`n"
$scriptChanged = @($startupScripts | Where-Object Changed).Count -gt 0
$iniChanged = -not (Test-Path -LiteralPath $scriptsIniPath) -or $iniChanged = -not (Test-Path -LiteralPath $scriptsIniPath) -or
[IO.File]::ReadAllText($scriptsIniPath) -cne $ini [IO.File]::ReadAllText($scriptsIniPath) -cne $ini
if (($scriptChanged -or $iniChanged) -and if (($scriptChanged -or $iniChanged) -and
$PSCmdlet.ShouldProcess($startupRoot, 'Install computer startup script')) { $PSCmdlet.ShouldProcess($startupRoot, 'Install computer startup script')) {
New-Item -ItemType Directory -Path (Split-Path $startupPath) -Force | Out-Null New-Item -ItemType Directory -Path (Join-Path $startupRoot 'Startup') -Force | Out-Null
[IO.File]::WriteAllText($startupPath, $source, [Text.UTF8Encoding]::new($false)) foreach ($startupScript in $startupScripts) {
if ($startupScript.Changed) {
[IO.File]::WriteAllText($startupScript.Path, $startupScript.Source,
[Text.UTF8Encoding]::new($false))
}
}
[IO.File]::WriteAllText($scriptsIniPath, $ini, [Text.Encoding]::Unicode) [IO.File]::WriteAllText($scriptsIniPath, $ini, [Text.Encoding]::Unicode)
$gpoDn = "CN={$($gpo.Id)},CN=Policies,CN=System,$($domain.DistinguishedName)" $gpoDn = "CN={$($gpo.Id)},CN=Policies,CN=System,$($domain.DistinguishedName)"
$adGpo = Get-ADObject -Identity $gpoDn -Server $DomainController ` $adGpo = Get-ADObject -Identity $gpoDn -Server $DomainController `
@@ -72,6 +95,6 @@ if (($scriptChanged -or $iniChanged) -and
GpoName = $GpoName GpoName = $GpoName
GpoId = $gpo.Id GpoId = $gpo.Id
TargetOu = $TargetOuDn TargetOu = $TargetOuDn
StartupScript = $startupPath StartupScripts = @($startupScripts.Path)
Changed = $scriptChanged -or $iniChanged Changed = $scriptChanged -or $iniChanged
} }
+5
View File
@@ -211,10 +211,14 @@ $serverScripts = @(
'Enable-SguAzureUserRoaming.ps1', 'Enable-SguAzureUserRoaming.ps1',
'Enable-SguServerRemoteManagement.ps1', 'Enable-SguServerRemoteManagement.ps1',
'Enable-SguWorkstationRemoteAccess.ps1', 'Enable-SguWorkstationRemoteAccess.ps1',
'Enable-SguWorkstationAdministrators.ps1',
'Get-SguUsageReport.ps1', 'Get-SguUsageReport.ps1',
'Get-SguBrokerLog.ps1', 'Get-SguBrokerLog.ps1',
'Install-SguDomainMonitoring.ps1', 'Install-SguDomainMonitoring.ps1',
'Install-SguWorkstationRemoteAccessPolicy.ps1', 'Install-SguWorkstationRemoteAccessPolicy.ps1',
'Install-SguDomainRemoteManagementPolicy.ps1',
'Sync-SguWacDomainConnections.ps1',
'Get-SguWorkstationRemoteManagementStatus.ps1',
'Publish-SguFsLogixClientDeployment.ps1', 'Publish-SguFsLogixClientDeployment.ps1',
'Install-SguRustDeskClient.ps1', 'Install-SguRustDeskClient.ps1',
'Install-SguRustDeskLinuxEnrollment.ps1', 'Install-SguRustDeskLinuxEnrollment.ps1',
@@ -226,6 +230,7 @@ $serverScripts = @(
'Register-SguClientCertificate.ps1', 'Register-SguClientCertificate.ps1',
'Register-SguRustDeskDevice.ps1', 'Register-SguRustDeskDevice.ps1',
'Set-LabBrokerDns.ps1', 'Set-LabBrokerDns.ps1',
'Set-SguInstitutionalPasswordPolicy.ps1',
'Set-SguDomainComputerPolicies.ps1', 'Set-SguDomainComputerPolicies.ps1',
'Set-SguLaboratorioWallpaperPolicy.ps1', 'Set-SguLaboratorioWallpaperPolicy.ps1',
'Set-SguLocalProfileSecurityPolicies.ps1', 'Set-SguLocalProfileSecurityPolicies.ps1',
@@ -0,0 +1,136 @@
[CmdletBinding(SupportsShouldProcess)]
param(
[string]$DomainController = $env:COMPUTERNAME,
[string]$BaseDn = 'DC=lci,DC=lasalle,DC=mx',
[string]$PolicyName = 'SGU - Institutional password authority',
[int]$Precedence = 100
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory -ErrorAction Stop
$domain = Get-ADDomain -Server $DomainController -ErrorAction Stop
if ($domain.DistinguishedName -ne $BaseDn) {
throw "BaseDn does not match the domain served by $DomainController."
}
if ($domain.DomainMode -lt 'Windows2012Domain') {
throw 'Fine-grained password policies require Windows Server 2012 domain functional level or newer.'
}
# AD's default password policy must remain intact for non-SGU accounts.
# 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",
"CN=SGU-Administrativos,OU=Administrativos,OU=Usuarios-SGU,$BaseDn",
"CN=SGU-Docentes,OU=Docentes,OU=Usuarios-SGU,$BaseDn"
)
foreach ($groupDn in $groups) {
$group = Get-ADGroup -Identity $groupDn -Server $DomainController -ErrorAction Stop
if ($group.GroupCategory -ne 'Security' -or $group.GroupScope -ne 'Global') {
throw "The password-policy subject must be a global security group: $groupDn"
}
}
$desired = @{
Precedence = $Precedence
ComplexityEnabled = $false
ReversibleEncryptionEnabled = $false
MinPasswordLength = 1
PasswordHistoryCount = 0
MinPasswordAge = [TimeSpan]::Zero
MaxPasswordAge = [TimeSpan]::Zero
LockoutThreshold = 0
LockoutDuration = [TimeSpan]::FromMinutes(10)
LockoutObservationWindow = [TimeSpan]::FromMinutes(10)
}
$policy = Get-ADFineGrainedPasswordPolicy -Filter * -Server $DomainController |
Where-Object { $_.Name -eq $PolicyName } |
Select-Object -First 1
if (-not $policy) {
if ($PSCmdlet.ShouldProcess($PolicyName, 'Create password policy limited to SGU role groups')) {
New-ADFineGrainedPasswordPolicy -Name $PolicyName @desired -Server $DomainController `
-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
}
}
else {
$different = @($desired.Keys | Where-Object { $policy.$_ -ne $desired[$_] })
if ($different.Count -gt 0 -and
$PSCmdlet.ShouldProcess($PolicyName, "Restore managed settings: $($different -join ', ')")) {
Set-ADFineGrainedPasswordPolicy -Identity $policy @desired -Server $DomainController | Out-Null
}
}
$policy = Get-ADFineGrainedPasswordPolicy -Filter * -Properties AppliesTo `
-Server $DomainController |
Where-Object { $_.Name -eq $PolicyName } |
Select-Object -First 1
if (-not $policy) {
if ($WhatIfPreference) { return }
throw "The fine-grained policy $PolicyName was not created."
}
foreach ($groupDn in $groups) {
if (@($policy.AppliesTo) -notcontains $groupDn) {
if ($PSCmdlet.ShouldProcess($groupDn, "Apply $PolicyName")) {
Add-ADFineGrainedPasswordPolicySubject -Identity $policy -Subjects $groupDn `
-Server $DomainController -ErrorAction Stop
}
}
}
# 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) {
foreach ($key in $desired.Keys) {
if ($policy.$key -ne $desired[$key]) {
throw "Password policy setting $key did not match the expected value."
}
}
foreach ($groupDn in $groups) {
if (@($policy.AppliesTo) -notcontains $groupDn) {
throw "Password policy is not applied to $groupDn."
}
}
}
[pscustomobject]@{
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 DirectoryRoleGroupMembershipAdded = new(1303, nameof(DirectoryRoleGroupMembershipAdded));
internal static readonly EventId DirectoryPasswordChangeDenied = new(1304, nameof(DirectoryPasswordChangeDenied)); internal static readonly EventId DirectoryPasswordChangeDenied = new(1304, nameof(DirectoryPasswordChangeDenied));
internal static readonly EventId DirectoryPhotoFailure = new(1305, nameof(DirectoryPhotoFailure)); 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 InfoAttributeMaximumLength = 1024;
private const int AccountDisabled = 0x0002; private const int AccountDisabled = 0x0002;
private const int NormalAccount = 0x0200; private const int NormalAccount = 0x0200;
private const int ReversiblePasswordEncryptionAllowed = 0x0080;
private static readonly Guid ChangePasswordExtendedRight = private static readonly Guid ChangePasswordExtendedRight =
new("AB721A53-1E2F-11D0-9819-00AA0040529B"); new("AB721A53-1E2F-11D0-9819-00AA0040529B");
private static readonly SecurityIdentifier EveryoneSid = private static readonly SecurityIdentifier EveryoneSid =
@@ -131,6 +132,10 @@ public sealed class ActiveDirectorySynchronizer(
// which ADSI SetPassword uses for each successful authentication. // which ADSI SetPassword uses for each successful authentication.
EnsureCannotChangePassword(user, identity.UserName); 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. // The exact institutional password received by the broker is passed to AD.
// It is not derived, transformed, written to disk, or included in logs. // It is not derived, transformed, written to disk, or included in logs.
user.Invoke("SetPassword", [password]); user.Invoke("SetPassword", [password]);
@@ -175,6 +180,23 @@ public sealed class ActiveDirectorySynchronizer(
institutionalUser); 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) internal static bool EnsureCannotChangePassword(ActiveDirectorySecurity security)
{ {
bool changed = false; bool changed = false;
+2 -1
View File
@@ -67,7 +67,8 @@ internal sealed class BrokerClient : IDisposable
return BrokerDecision.Authorized(authorized.Domain, authorized.UserName); return BrokerDecision.Authorized(authorized.Domain, authorized.UserName);
} }
return BrokerDecision.Unavailable($"BROKER_HTTP_{(int)response.StatusCode}"); ErrorBody? unavailable = await ReadJsonAsync<ErrorBody>(response, timeout.Token).ConfigureAwait(false);
return BrokerDecision.Unavailable(unavailable?.Code ?? $"BROKER_HTTP_{(int)response.StatusCode}");
} }
catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested) catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
{ {
@@ -80,17 +80,27 @@ internal sealed class SguCredentialTile : CredentialTile3
return DomainCredential(decision.Domain!, decision.UserName!, securePassword); return DomainCredential(decision.Domain!, decision.UserName!, securePassword);
} }
// An SGU rejection does not create an account. Pass the unchanged // An explicit SGU rejection is authoritative even when an older AD
// credential to Windows so an existing AD account with the same // verifier for the same institutional key still exists.
// name can still authenticate. A non-existent account is rejected if (decision.Kind == BrokerDecisionKind.InvalidCredentials)
// by the domain controller. {
return Failure("Usuario o contraseña incorrectos.");
}
// 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/SGU outage permits the documented cached
// domain-credential path for an existing account.
return DomainCredential( return DomainCredential(
domain, domain,
userName, userName,
securePassword, securePassword,
decision.Kind == BrokerDecisionKind.Unavailable "El servicio de autenticación no está disponible; Windows validará la última contraseña de dominio registrada.");
? "El servicio institucional no está disponible; Windows validará la contraseña guardada en el dominio."
: null);
} }
finally finally
{ {
@@ -2,9 +2,15 @@ $repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
$synchronizerPath = Join-Path $repositoryRoot 'src\SGU.AuthBroker\Services\ActiveDirectorySynchronizer.cs' $synchronizerPath = Join-Path $repositoryRoot 'src\SGU.AuthBroker\Services\ActiveDirectorySynchronizer.cs'
$deployPath = Join-Path $repositoryRoot 'scripts\Deploy-AuthBroker.ps1' $deployPath = Join-Path $repositoryRoot 'scripts\Deploy-AuthBroker.ps1'
$userPolicyPath = Join-Path $repositoryRoot 'scripts\Set-SguDomainUserPolicies.ps1' $userPolicyPath = Join-Path $repositoryRoot 'scripts\Set-SguDomainUserPolicies.ps1'
$passwordPolicyPath = Join-Path $repositoryRoot 'scripts\Set-SguInstitutionalPasswordPolicy.ps1'
$bootstrapPath = Join-Path $repositoryRoot 'scripts\Initialize-SguDomainController.ps1'
$packagePath = Join-Path $repositoryRoot 'scripts\New-SguBootstrapPackages.ps1'
$synchronizer = Get-Content -LiteralPath $synchronizerPath -Raw $synchronizer = Get-Content -LiteralPath $synchronizerPath -Raw
$deploy = Get-Content -LiteralPath $deployPath -Raw $deploy = Get-Content -LiteralPath $deployPath -Raw
$userPolicy = Get-Content -LiteralPath $userPolicyPath -Raw $userPolicy = Get-Content -LiteralPath $userPolicyPath -Raw
$passwordPolicy = Get-Content -LiteralPath $passwordPolicyPath -Raw
$bootstrap = Get-Content -LiteralPath $bootstrapPath -Raw
$package = Get-Content -LiteralPath $packagePath -Raw
Describe 'SGU Auth Broker password authority' { Describe 'SGU Auth Broker password authority' {
It 'denies the Change Password extended right to SELF and Everyone before SetPassword' { It 'denies the Change Password extended right to SELF and Everyone before SetPassword' {
@@ -25,4 +31,17 @@ Describe 'SGU Auth Broker password authority' {
$userPolicy | Should Match "disableChangePasswordValueName = 'DisableChangePassword'" $userPolicy | Should Match "disableChangePasswordValueName = 'DisableChangePassword'"
$userPolicy | Should Match '(?s)-ValueName \$disableChangePasswordValueName.*-Type DWord.*-Value 1' $userPolicy | Should Match '(?s)-ValueName \$disableChangePasswordValueName.*-Type DWord.*-Value 1'
} }
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"
}
$passwordPolicy | Should Match 'ComplexityEnabled = \$false'
$passwordPolicy | Should Match 'MinPasswordLength = 1'
$passwordPolicy | Should Match 'PasswordHistoryCount = 0'
$passwordPolicy | Should Match 'MaxPasswordAge = \[TimeSpan\]::Zero'
$passwordPolicy | Should Not Match 'Set-ADDefaultDomainPasswordPolicy'
$bootstrap | Should Match 'Set-SguInstitutionalPasswordPolicy\.ps1'
$package | Should Match "'Set-SguInstitutionalPasswordPolicy.ps1'"
}
} }
@@ -46,6 +46,7 @@ public sealed class BrokerClientTests
TestContext.Current.CancellationToken); TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.InvalidCredentials, decision.Kind); Assert.Equal(BrokerDecisionKind.InvalidCredentials, decision.Kind);
Assert.Equal("INVALID_INSTITUTIONAL_CREDENTIALS", decision.ErrorCode);
} }
[Fact] [Fact]
@@ -61,6 +62,23 @@ public sealed class BrokerClientTests
TestContext.Current.CancellationToken); TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind); Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind);
Assert.Equal("NTLM_UPSTREAM_ERROR", decision.ErrorCode);
}
[Fact]
public async Task SynchronizationFailureRetainsItsSpecificErrorCode()
{
using BrokerClient client = new(
CreateSettings(),
new CapturingHandler(HttpStatusCode.ServiceUnavailable, "{\"code\":\"DIRECTORY_SYNCHRONIZATION_FAILED\"}"));
BrokerDecision decision = await client.AuthenticateAsync(
"AL250792",
"SGUAccepted",
TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind);
Assert.Equal("DIRECTORY_SYNCHRONIZATION_FAILED", decision.ErrorCode);
} }
private static ProviderSettings CreateSettings() => new() private static ProviderSettings CreateSettings() => new()