Compare commits

..
4 Commits
26 changed files with 820 additions and 83 deletions

No files matched your search

+17 -10
View File
@@ -13,20 +13,27 @@ Ready-to-run bootstrap packages are published on the
## Authentication contract ## Authentication contract
1. The Windows tile collects a `DO`, `AL`, or `AD` institutional key and a password. 1. Windows selects **Acceso Institucional** by default. The built-in
2. It sends that exact password over mutually authenticated TLS to the broker. Microsoft password provider stays available for recovery.
3. The broker validates the same key/password pair against the lightweight SGU 2. Ordinary domain usernames go straight to Windows for Active Directory
NTLM root. Only an authoritative `401`/`403` rejects the credential. authentication. A `DO`, `AL`, or `AD` key is checked against SGU first.
4. After successful authentication, the broker makes a separately bounded, 3. The tile sends recognized institutional keys and their exact passwords over
best-effort request for the minimum available SGU profile fields. mutually authenticated TLS. After SGU accepts the credential, the broker
5. On success, the broker creates or moves the AD user, updates the available performs an idempotent Active Directory UPSERT: it creates or repairs the
name/mail/title/department/address metadata when available, and sets the AD password account, role OU and group, supported profile fields, and AD password.
to the exact submitted password. 4. If SGU rejects the key or is unavailable, the unchanged credentials go to
6. The Credential Provider serializes the original `SecureString` to Windows. Windows. Existing AD accounts can authenticate there; unknown or misspelled
accounts are rejected by Windows and are never created.
No derived password is created. Passwords are not written to a database, file, No derived password is created. Passwords are not written to a database, file,
event log, application log, command line, or response. event log, application log, command line, or response.
This makes Active Directory the only Windows sign-in account while preserving
automatic synchronization: if a person changes their institutional password,
the next successful Acceso Institucional sign-in updates the domain password
before Windows continues. A matching prefix alone never creates an account;
the institutional authority must first accept the submitted password.
For administrative accounts, profile enrichment first verifies the employee For administrative accounts, profile enrichment first verifies the employee
number against the incident overview, then reads the structured given names and number against the incident overview, then reads the structured given names and
surnames from `datos/personales.aspx` and the postal address from surnames from `datos/personales.aspx` and the postal address from
+23 -11
View File
@@ -52,15 +52,24 @@ Broker timeout, TLS failure, 429, or 5xx
-> only the last AD password succeeds -> only the last AD password succeeds
``` ```
An explicit `400` or `401` from the broker is different: the provider displays An explicit `400` or `401` from SGU does not create or update an account. The
an error and does not serialize the rejected credential. tile submits the unchanged credentials to Windows, which accepts them only if
they match an existing Active Directory account.
## Account synchronization ## Account synchronization
The broker normalizes the username to uppercase and accepts exactly two letters The visible Windows experience is one **Acceso Institucional** sign-in tile,
plus six digits. It searches `BaseDn` by `sAMAccountName`, creates the user when selected by default, with `Usuario` and `Contraseña`. Ordinary usernames go
absent, moves it to the mapped OU when required, sets `userPrincipalName`, and straight to Windows for domain authentication. A `DO`, `AL`, or `AD` key is
passes the submitted password directly to ADSI `SetPassword`. checked by the broker against SGU. After SGU accepts the submitted password,
the broker searches `BaseDn` by `sAMAccountName`, creates the user when absent,
moves it to the mapped OU when required, sets `userPrincipalName`, and passes
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 rejects the credential or is unavailable, the unchanged credentials go to
Windows; only an existing AD account can then authenticate. A matching username
pattern alone never provisions an account.
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
@@ -125,9 +134,10 @@ Windows client maps the group into its local **Remote Desktop Users** group.
Every synchronized user also receives `La Salle` in the AD Every synchronized user also receives `La Salle` in the AD
`company` attribute unless deployment configuration supplies another default. `company` attribute unless deployment configuration supplies another default.
The generic SGU credential is rendered as a dedicated branded tile instead of The generic Acceso Institucional credential is rendered as a dedicated
being grouped below the anonymous **Other user** tile. Machine policy assigns branded tile instead of being grouped below the anonymous **Other user** tile.
the SGU CLSID as the default provider, hides the last signed-in identity, and Machine policy assigns
the provider CLSID as the default provider, hides the last signed-in identity, and
disables local-user enumeration while retaining the built-in Microsoft password disables local-user enumeration while retaining the built-in Microsoft password
provider and its **Other user** recovery path. The computer GPO also applies provider and its **Other user** recovery path. The computer GPO also applies
Windows' native default account picture to named Windows accounts; client Windows' native default account picture to named Windows accounts; client
@@ -146,8 +156,10 @@ and `Administrativos` are direct child OUs beneath it. The domain GPO
per-user `DisableLockWorkstation` and `DisableChangePassword` policies and per-user `DisableLockWorkstation` and `DisableChangePassword` policies and
disables screen savers for the complete hierarchy. The enforced laboratory disables screen savers for the complete hierarchy. The enforced laboratory
loopback GPO also applies `DisableLockWorkstation` and disables screen savers loopback GPO also applies `DisableLockWorkstation` and disables screen savers
for every account that logs on to a laboratory computer, including local for domain accounts. Its computer-startup script runs as `LocalSystem` and
accounts; it deliberately does not apply `DisableChangePassword` to them. The computer GPO writes the same setting into every existing local profile and the Default
profile template, covering local accounts such as `ing`; it deliberately does
not apply `DisableChangePassword` to them. The computer GPO
`SGU - Windows client experience` is linked to `OU=Laboratorio`; it suppresses `SGU - Windows client experience` is linked to `OU=Laboratorio`; it suppresses
first-logon/privacy/diagnostic prompts, disables location, and enforces first-logon/privacy/diagnostic prompts, disables location, and enforces
always-on display, sleep, and hibernation settings for managed clients. The always-on display, sleep, and hibernation settings for managed clients. The
+13 -3
View File
@@ -187,6 +187,13 @@ pantalla, suspensión, hibernación y suspensión híbrida, conectado a corrient
batería. El guard de enrolamiento vuelve a aplicar `powercfg /hibernate off` y batería. El guard de enrolamiento vuelve a aplicar `powercfg /hibernate off` y
los tiempos en cero al inicio y diariamente. los tiempos en cero al inicio y diariamente.
El enrollment de Windows también aplica `DisableLockWorkstation=1` a **todos
los perfiles locales existentes** y a la plantilla `C:\Users\Default`. El
trabajo se ejecuta una sola vez como `LocalSystem` y termina; no deja una tarea
programada. La GPO de Laboratorio repite la misma operación como script de
inicio de equipo para que un cliente ya unido, o una cuenta local creada
después, también reciba la restricción.
Esa GPO también ejecuta el generador local del fondo de bienvenida y aplica el Esa GPO también ejecuta el generador local del fondo de bienvenida y aplica el
fondo azul base a la pantalla de bloqueo. El fondo individual se crea al abrir la fondo azul base a la pantalla de bloqueo. El fondo individual se crea al abrir la
sesión con el nombre del usuario y `location`/OU del equipo. Los alumnos conservan sesión con el nombre del usuario y `location`/OU del equipo. Los alumnos conservan
@@ -225,12 +232,15 @@ administradores.
El proveedor usa un mosaico genérico dedicado, no una credencial asociada al SID El proveedor usa un mosaico genérico dedicado, no una credencial asociada al SID
anónimo de **Other user**. Windows muestra la imagen institucional y la etiqueta anónimo de **Other user**. Windows muestra la imagen institucional y la etiqueta
`La Salle · Acceso SGU`; el encabezado `Acceso institucional SGU` `Acceso Institucional`; el encabezado `Iniciar sesión` se publica como
se publica como `CPFT_LARGE_TEXT` solamente en el mosaico seleccionado. LogonUI `CPFT_LARGE_TEXT` solamente en el mosaico seleccionado. El instalador selecciona
ese proveedor por defecto. Los usuarios de dominio se validan contra Active
Directory; las claves institucionales aceptadas por SGU hacen el UPSERT en AD
desde ese mismo mosaico. LogonUI
elige la familia, el peso y el tamaño final y no expone opciones de tipografía a elige la familia, el peso y el tamaño final y no expone opciones de tipografía a
un Credential Provider. un Credential Provider.
La configuración soportada garantiza que SGU queda seleccionado por defecto y La configuración soportada garantiza que Acceso Institucional queda seleccionado por defecto y
que no se conserva el último usuario. El orden vertical exacto de mosaicos lo que no se conserva el último usuario. El orden vertical exacto de mosaicos lo
decide LogonUI y no tiene una directiva pública. Por seguridad no se filtra ni decide LogonUI y no tiene una directiva pública. Por seguridad no se filtra ni
se elimina **Other user**: Microsoft recomienda conservar al menos un proveedor se elimina **Other user**: Microsoft recomienda conservar al menos un proveedor
+1 -1
View File
@@ -136,7 +136,7 @@ On Windows 10:
``` ```
Use Lithnet's `Invoke-CredUI` test utility when available, or sign out/restart Use Lithnet's `Invoke-CredUI` test utility when available, or sign out/restart
the VM and select **Acceso institucional SGU**. Keep the built-in Windows the VM and select **Acceso Institucional**. Keep the built-in Windows
password provider available through **Other user**. password provider available through **Other user**.
On the domain controller, apply the SGU user and computer policies once: On the domain controller, apply the SGU user and computer policies once:
+8 -4
View File
@@ -17,8 +17,11 @@ los valores escritos. Admite `-WhatIf`. El vínculo está habilitado y forzado,
prioridad 1, para que también alcance las OU hijas con herencia bloqueada. prioridad 1, para que también alcance las OU hijas con herencia bloqueada.
- Loopback **Merge** aplica las opciones de usuario según la OU de la computadora - Loopback **Merge** aplica las opciones de usuario según la OU de la computadora
y conserva las otras políticas del usuario. Por ello alcanza usuarios locales y conserva las otras políticas del usuario. Para no depender de que Windows
y de dominio que inicien sesión en un equipo de Laboratorio. procese una GPO de usuario para una cuenta local, la GPO también instala un
script de **inicio de equipo** que corre como `LocalSystem`: escribe la regla
en cada perfil local existente y en `C:\Users\Default\NTUSER.DAT`. Así `ing`,
`alumno` y cualquier cuenta local nueva reciben `DisableLockWorkstation=1`.
- `NoChangingWallPaper=1` bloquea el cambio desde Personalización. - `NoChangingWallPaper=1` bloquea el cambio desde Personalización.
- `DisableLockWorkstation=1` deshabilita Win+L y la opción **Bloquear** para - `DisableLockWorkstation=1` deshabilita Win+L y la opción **Bloquear** para
todos esos usuarios; `ScreenSaveActive=0` evita que un protector de pantalla todos esos usuarios; `ScreenSaveActive=0` evita que un protector de pantalla
@@ -32,8 +35,9 @@ de inicio de sesión. No aplica a Linux. Es una restricción de la interfaz de
Windows, no una barrera contra administradores ni contra la modificación directa Windows, no una barrera contra administradores ni contra la modificación directa
del JPG, que está dentro del perfil del usuario. del JPG, que está dentro del perfil del usuario.
Tras actualizar las políticas del equipo, cierre e inicie sesión para procesar Tras actualizar las políticas del equipo, reinicie el equipo o ejecute de nuevo
loopback y comprobar la política de usuario con `gpresult /h resultado.html`. el enrollment para procesar el script de perfiles locales. Después, cierre e
inicie sesión para comprobar la política de usuario con `gpresult /h resultado.html`.
Compruebe también visualmente el fondo y Personalización en una sesión de dominio. Compruebe también visualmente el fondo y Personalización en una sesión de dominio.
La validación por WinRM no sustituye esa prueba de escritorio interactivo. La validación por WinRM no sustituye esa prueba de escritorio interactivo.
+17
View File
@@ -0,0 +1,17 @@
# SGU Credential Provider 0.6.12
Esta corrección hace que la restricción **No bloquear estación de trabajo** sea
efectiva también para cuentas locales de equipos Windows del Laboratorio.
- Durante el enrollment y su reparación, se ejecuta un trabajador temporal como
`LocalSystem` que fija `DisableLockWorkstation=1` en cada perfil local
existente y en `C:\Users\Default\NTUSER.DAT`.
- La GPO `SGU - Laboratorio wallpaper protection` instala el mismo código como
script de inicio de equipo. Esto alcanza máquinas ya unidas al dominio en su
siguiente arranque, incluso si sólo se usa una cuenta local como `ing`.
- El script de inicio usa un lanzador `cmd` con PowerShell en modo Bypass para
no depender de la política de ejecución local. El enrollment no deja una
tarea programada permanente.
Los usuarios de dominio siguen recibiendo la directiva por su GPO de usuario y
por loopback. Esta versión sólo corrige la cobertura de perfiles locales.
+15
View File
@@ -0,0 +1,15 @@
# SGU Credential Provider 0.6.13
La pantalla de inicio de sesión ahora presenta una sola credencial visible:
**La Salle**, con los campos `Usuario` y `Contraseña`. Ya no muestra el texto
“Acceso Institucional SGU”.
La autenticación institucional permanece dentro del broker, sin una segunda
captura. Después de cada autenticación válida, el broker ejecuta su UPSERT de
Active Directory: crea o repara la cuenta, la OU, el grupo, los datos de perfil
disponibles y la contraseña de AD. Así, la siguiente sesión después de cambiar
una contraseña institucional sincroniza esa contraseña con el dominio.
El patrón `DO`, `AL` o `AD` con seis dígitos continúa siendo sólo un formato de
usuario. No autoriza ni crea cuentas por sí mismo: la autoridad institucional
debe validar la contraseña antes de que el UPSERT haga cambios en AD.
+18
View File
@@ -0,0 +1,18 @@
# SGU Credential Provider 0.6.14
El mosaico predeterminado se llama **Acceso Institucional**. En él se pueden
usar tanto cuentas existentes de Active Directory como claves institucionales
DO, AL y AD:
- Los usuarios de dominio que no son claves institucionales se envían
directamente a Windows para validación por Active Directory.
- Las claves institucionales se validan primero contra SGU. Si SGU las acepta,
el broker enriquece o actualiza la cuenta y sincroniza la contraseña con AD.
- Si SGU rechaza la clave o no está disponible, Windows valida la credencial
existente contra AD o las credenciales de dominio guardadas en caché. Una
cuenta inexistente no se crea sin una validación SGU correcta.
- El instalador y la GPO seleccionan **Acceso Institucional** como predeterminado
y conservan el proveedor de contraseña de Microsoft para recuperación.
El mosaico recopila el usuario y la contraseña una sola vez. La contraseña no
se deriva ni se guarda en un archivo, base de datos o registro.
+8 -6
View File
@@ -87,13 +87,15 @@ Use an enterprise CA with revocation checking in production.
## Recovery and availability ## Recovery and availability
The provider distinguishes an authoritative rejection from unavailable The provider distinguishes an SGU rejection from unavailable infrastructure:
infrastructure:
- `400`/`401`: fail closed and show an error. - `400`/`401`: do not create or update the account; submit the unchanged
- timeout, TLS/connectivity error, `429`, or `5xx`: submit the unchanged credential credential to Windows so an existing AD account can authenticate.
to Windows. Windows must still validate it against AD or the cached domain - timeout, TLS/connectivity error, `429`, or `5xx`: submit the unchanged
verifier, so this does not grant access without the last synchronized password. credential to Windows. Windows must still validate it against AD or its cached
domain verifier, so this does not grant access without a domain credential.
- usernames that do not match the institutional key format go directly to
Windows and are never sent to SGU or provisioned by the broker.
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
+3 -2
View File
@@ -97,8 +97,9 @@ usuario que cerró sesión y deshabilita la enumeración de usuarios locales en
equipo unido al dominio. No modifica ni oculta el proveedor de contraseña de equipo unido al dominio. No modifica ni oculta el proveedor de contraseña de
Microsoft; **Other user** permanece como ruta de recuperación. Microsoft; **Other user** permanece como ruta de recuperación.
Cerrar sesión o reiniciar el equipo. El acceso SGU debe quedar seleccionado por Cerrar sesión o reiniciar el equipo. **Acceso Institucional** debe quedar
defecto y el proveedor de contraseña de Microsoft debe permanecer disponible. seleccionado por defecto; el proveedor nativo de Microsoft permanece disponible
para recuperación.
## 5. Verificación ## 5. Verificación
+1
View File
@@ -44,6 +44,7 @@ foreach ($scriptName in @(
'Install-CredentialProvider.ps1', 'Install-CredentialProvider.ps1',
'Install-SguEnrollmentGuard.ps1', 'Install-SguEnrollmentGuard.ps1',
'Set-SguStandardLocalUser.ps1', 'Set-SguStandardLocalUser.ps1',
'Set-SguLocalProfileSecurityPolicies.ps1',
'Test-SguClientEnrollment.ps1', 'Test-SguClientEnrollment.ps1',
'Repair-SguClientEnrollment.ps1', 'Repair-SguClientEnrollment.ps1',
'Enable-LabRemoteAccess.ps1', 'Enable-LabRemoteAccess.ps1',
+2 -5
View File
@@ -300,10 +300,7 @@ if ($PSCmdlet.ShouldProcess($installPath, 'Install and register the SGU Credenti
New-ItemProperty -Path $classRegistryPath -Name ThreadingModel -Value Both -PropertyType String -Force | Out-Null New-ItemProperty -Path $classRegistryPath -Name ThreadingModel -Value Both -PropertyType String -Force | Out-Null
New-Item -Path $providerRegistryPath -Force | Out-Null New-Item -Path $providerRegistryPath -Force | Out-Null
# Windows PowerShell 5.1 interprets an UTF-8 script without a BOM using the Set-Item -Path $providerRegistryPath -Value 'Acceso Institucional'
# current ANSI code page. Construct the middle dot from its Unicode value so
# the LogonUI registry label remains correct on every client locale.
Set-Item -Path $providerRegistryPath -Value ('La Salle {0} Acceso SGU' -f [char]0x00B7)
if (-not $DoNotSetAsDefaultCredentialProvider) { if (-not $DoNotSetAsDefaultCredentialProvider) {
if (-not (Test-Path -LiteralPath $defaultProviderPolicyPath)) { if (-not (Test-Path -LiteralPath $defaultProviderPolicyPath)) {
@@ -316,7 +313,7 @@ if ($PSCmdlet.ShouldProcess($installPath, 'Install and register the SGU Credenti
-Force | Out-Null -Force | Out-Null
} }
# Do not leave a signed-out SGU identity exposed as a persistent user tile. # Do not leave a signed-out domain identity exposed as a persistent user tile.
# The Microsoft password provider remains registered and supplies Other user. # The Microsoft password provider remains registered and supplies Other user.
if (-not (Test-Path -LiteralPath $interactiveLogonPolicyPath)) { if (-not (Test-Path -LiteralPath $interactiveLogonPolicyPath)) {
New-Item -Path $interactiveLogonPolicyPath -Force | Out-Null New-Item -Path $interactiveLogonPolicyPath -Force | Out-Null
@@ -0,0 +1,148 @@
[CmdletBinding(SupportsShouldProcess)]
param(
[string]$Version = '0.6.14',
[ValidatePattern('^https://')]
[string]$ClientPackageUri = 'https://gitea.lci.ulsa.mx/alexrg/SGU-CredentialProvider/releases/download/v0.6.14/sgu-windows-client-bootstrap-0.6.14.zip',
[ValidatePattern('^[0-9A-Fa-f]{64}$')]
[string]$ClientPackageSha256 = 'A409BC60E90EB13029945FCBBAAC3F17547F98ACE9D58032673F2F9350D17669',
[string]$GpoName = 'SGU - Credential Provider update',
[string]$DomainController = $env:COMPUTERNAME
)
$ErrorActionPreference = 'Stop'
$identity = [Security.Principal.WindowsIdentity]::GetCurrent()
$principal = [Security.Principal.WindowsPrincipal]::new($identity)
if (-not $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
throw 'Run this script from an elevated Windows PowerShell session on a domain controller or management host.'
}
Import-Module ActiveDirectory -ErrorAction Stop
Import-Module GroupPolicy -ErrorAction Stop
$domain = Get-ADDomain -Server $DomainController -ErrorAction Stop
$domainDnsRoot = $domain.DNSRoot
$domainDn = $domain.DistinguishedName
$gpo = Get-GPO -Name $GpoName -Domain $domainDnsRoot -Server $DomainController -ErrorAction SilentlyContinue
if (-not $gpo -and $PSCmdlet.ShouldProcess($GpoName, 'Create computer startup update policy')) {
$gpo = New-GPO -Name $GpoName -Domain $domainDnsRoot -Server $DomainController
}
if (-not $gpo) {
throw "The GPO '$GpoName' does not exist and was not created."
}
$existingLink = @(Get-GPInheritance -Target $domainDn -Domain $domainDnsRoot -Server $DomainController).GpoLinks |
Where-Object DisplayName -eq $GpoName |
Select-Object -First 1
if (-not $existingLink -and
$PSCmdlet.ShouldProcess($domainDn, "Link and enable '$GpoName'")) {
New-GPLink -Name $GpoName -Target $domainDn -Domain $domainDnsRoot -Server $DomainController -LinkEnabled Yes | Out-Null
}
elseif ($existingLink -and
$existingLink.Enabled -notin @($true, 'Yes') -and
$PSCmdlet.ShouldProcess($domainDn, "Enable '$GpoName'")) {
Set-GPLink -Name $GpoName -Target $domainDn -Domain $domainDnsRoot -Server $DomainController -LinkEnabled Yes | Out-Null
}
$systemPolicyKey = 'HKLM\Software\Policies\Microsoft\Windows\System'
$winlogonPolicyKey = 'HKLM\Software\Policies\Microsoft\Windows NT\CurrentVersion\Winlogon'
if ($PSCmdlet.ShouldProcess($GpoName, 'Make the computer startup script synchronous')) {
Set-GPRegistryValue -Name $GpoName -Domain $domainDnsRoot -Server $DomainController `
-Key $systemPolicyKey -ValueName 'RunStartupScriptSync' -Type DWord -Value 1
Set-GPRegistryValue -Name $GpoName -Domain $domainDnsRoot -Server $DomainController `
-Key $winlogonPolicyKey -ValueName 'SyncForegroundPolicy' -Type DWord -Value 1
}
$scriptName = "Update-SguCredentialProvider-$Version.ps1"
$gpoScriptsPath = Join-Path $env:WINDIR "SYSVOL\domain\Policies\{$($gpo.Id)}\Machine\Scripts"
$startupPath = Join-Path $gpoScriptsPath 'Startup'
$powershellScriptsIniPath = Join-Path $gpoScriptsPath 'psscripts.ini'
$scriptPath = Join-Path $startupPath $scriptName
$startupScript = @"
`$ErrorActionPreference = 'Stop'
`$version = '$Version'
`$packageUri = '$ClientPackageUri'
`$expectedSha256 = '$($ClientPackageSha256.ToUpperInvariant())'
`$computerSystem = Get-CimInstance Win32_ComputerSystem
if (-not `$computerSystem.PartOfDomain -or `$computerSystem.DomainRole -ge 4) {
exit 0
}
`$updateRoot = Join-Path `$env:ProgramData "SGU\CredentialProviderUpdates\`$version"
`$markerPath = Join-Path `$updateRoot 'complete.marker'
if (Test-Path -LiteralPath `$markerPath -PathType Leaf) {
exit 0
}
New-Item -ItemType Directory -Path `$updateRoot -Force | Out-Null
`$archivePath = Join-Path `$updateRoot 'client-bootstrap.zip'
`$stagePath = Join-Path `$updateRoot 'package'
if ((Test-Path -LiteralPath `$archivePath -PathType Leaf) -and
(Get-FileHash -LiteralPath `$archivePath -Algorithm SHA256).Hash -ne `$expectedSha256) {
Remove-Item -LiteralPath `$archivePath -Force
}
if (-not (Test-Path -LiteralPath `$archivePath -PathType Leaf)) {
Invoke-WebRequest -Uri `$packageUri -OutFile `$archivePath -UseBasicParsing -TimeoutSec 600
}
if ((Get-FileHash -LiteralPath `$archivePath -Algorithm SHA256).Hash -ne `$expectedSha256) {
throw 'The SGU Credential Provider update package did not match its expected SHA-256.'
}
`$installScript = Join-Path `$stagePath 'payload\scripts\Install-CredentialProvider.ps1'
if (-not (Test-Path -LiteralPath `$installScript -PathType Leaf)) {
if (Test-Path -LiteralPath `$stagePath -PathType Container) {
Remove-Item -LiteralPath `$stagePath -Recurse -Force
}
Expand-Archive -LiteralPath `$archivePath -DestinationPath `$stagePath -Force
}
if (-not (Test-Path -LiteralPath `$installScript -PathType Leaf)) {
throw 'The verified update package did not contain Install-CredentialProvider.ps1.'
}
`$settingsPath = Join-Path `$env:ProgramData 'SGU\CredentialProvider\settings.json'
`$settings = Get-Content -LiteralPath `$settingsPath -Raw | ConvertFrom-Json
`$installParameters = @{
PublishPath = (Join-Path `$stagePath 'payload\credential-provider')
BrokerEndpoint = [string]`$settings.BrokerEndpoint
ClientCertificateThumbprint = [string]`$settings.ClientCertificateThumbprint
ServerCertificateThumbprint = [string]`$settings.ServerCertificateThumbprint
DomainNetbios = [string]`$settings.DomainNetbios
TimeoutSeconds = [int]`$settings.TimeoutSeconds
}
`$dotnet = Get-Command dotnet -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Source -ErrorAction SilentlyContinue
`$runtimeInstalled = `$dotnet -and (& `$dotnet --list-runtimes | Select-String '^Microsoft\.NETCore\.App 10\.')
if (-not `$runtimeInstalled) {
`$runtimeInstaller = Get-ChildItem -LiteralPath (Join-Path `$stagePath 'payload\prerequisites') -Filter '*x64*.exe' -File |
Select-Object -First 1
if (-not `$runtimeInstaller) {
throw 'The update package does not contain the required .NET x64 runtime installer.'
}
`$installParameters.InstallDotNetRuntime = `$true
`$installParameters.DotNetRuntimeInstallerPath = `$runtimeInstaller.FullName
}
& `$installScript @installParameters | Out-Null
[IO.File]::WriteAllText(`$markerPath, (Get-Date).ToUniversalTime().ToString('o'), [Text.UTF8Encoding]::new(`$false))
"@
if ($PSCmdlet.ShouldProcess($startupPath, "Install '$scriptName' as a computer startup script")) {
New-Item -ItemType Directory -Path $startupPath -Force | Out-Null
[IO.File]::WriteAllText($scriptPath, $startupScript, [Text.UTF8Encoding]::new($false))
$scriptsIni = "[Startup]`r`n0CmdLine=$scriptName`r`n0Parameters=`r`n"
[IO.File]::WriteAllText($powershellScriptsIniPath, $scriptsIni, [Text.UTF8Encoding]::new($false))
}
[pscustomobject]@{
GpoName = $gpo.DisplayName
GpoId = $gpo.Id
LinkedTarget = $domainDn
StartupScript = $scriptPath
Version = $Version
PackageSha256 = $ClientPackageSha256.ToUpperInvariant()
}
+2
View File
@@ -129,6 +129,7 @@ $clientScripts = @(
'Register-SguClientCertificate.ps1', 'Register-SguClientCertificate.ps1',
'Repair-SguClientEnrollment.ps1', 'Repair-SguClientEnrollment.ps1',
'Set-SguStandardLocalUser.ps1', 'Set-SguStandardLocalUser.ps1',
'Set-SguLocalProfileSecurityPolicies.ps1',
'Test-SguClientEnrollment.ps1' 'Test-SguClientEnrollment.ps1'
) )
foreach ($scriptName in $clientScripts) { foreach ($scriptName in $clientScripts) {
@@ -225,6 +226,7 @@ $serverScripts = @(
'Set-LabBrokerDns.ps1', 'Set-LabBrokerDns.ps1',
'Set-SguDomainComputerPolicies.ps1', 'Set-SguDomainComputerPolicies.ps1',
'Set-SguLaboratorioWallpaperPolicy.ps1', 'Set-SguLaboratorioWallpaperPolicy.ps1',
'Set-SguLocalProfileSecurityPolicies.ps1',
'Set-SguDomainUserPolicies.ps1' 'Set-SguDomainUserPolicies.ps1'
) )
foreach ($scriptName in $serverScripts) { foreach ($scriptName in $serverScripts) {
+118 -1
View File
@@ -4,7 +4,8 @@ param(
[string]$TargetOuDn = 'OU=Laboratorio,DC=lci,DC=lasalle,DC=mx', [string]$TargetOuDn = 'OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$GpoName = 'SGU - Laboratorio wallpaper protection', [string]$GpoName = 'SGU - Laboratorio wallpaper protection',
[string]$DomainController = $env:COMPUTERNAME, [string]$DomainController = $env:COMPUTERNAME,
[string]$WallpaperPath = '%LOCALAPPDATA%\SGU\Wallpapers\welcome-%COMPUTERNAME%.jpg' [string]$WallpaperPath = '%LOCALAPPDATA%\SGU\Wallpapers\welcome-%COMPUTERNAME%.jpg',
[string]$LocalProfilePolicyScriptPath = (Join-Path $PSScriptRoot 'Set-SguLocalProfileSecurityPolicies.ps1')
) )
$ErrorActionPreference = 'Stop' $ErrorActionPreference = 'Stop'
@@ -12,6 +13,118 @@ Import-Module ActiveDirectory -ErrorAction Stop
Import-Module GroupPolicy -ErrorAction Stop Import-Module GroupPolicy -ErrorAction Stop
$domainName = (Get-ADDomain -Server $DomainController).DNSRoot $domainName = (Get-ADDomain -Server $DomainController).DNSRoot
Get-ADOrganizationalUnit -Identity $TargetOuDn -Server $DomainController -ErrorAction Stop | Out-Null Get-ADOrganizationalUnit -Identity $TargetOuDn -Server $DomainController -ErrorAction Stop | Out-Null
function Set-SguLocalProfilePolicyStartupScript {
param(
[Parameter(Mandatory)]$Gpo,
[Parameter(Mandatory)][string]$DomainName,
[Parameter(Mandatory)][string]$DomainController,
[Parameter(Mandatory)][string]$SourceScript
)
if (-not (Test-Path -LiteralPath $SourceScript -PathType Leaf)) {
throw 'Set-SguLocalProfileSecurityPolicies.ps1 must be beside Set-SguLaboratorioWallpaperPolicy.ps1.'
}
$domainDn = (Get-ADDomain -Server $DomainController).DistinguishedName
$gpoAdPath = "CN={$($Gpo.Id)},CN=Policies,CN=System,$domainDn"
$gpoAd = Get-ADObject -Identity $gpoAdPath -Properties gPCFileSysPath,gPCMachineExtensionNames,versionNumber `
-Server $DomainController -ErrorAction Stop
$scriptsRoot = Join-Path $gpoAd.gPCFileSysPath 'Machine\Scripts'
$startupRoot = Join-Path $scriptsRoot 'Startup'
$destinationScript = Join-Path $startupRoot 'Set-SguLocalProfileSecurityPolicies.ps1'
$startupLauncher = Join-Path $startupRoot 'Start-SguLocalProfileSecurityPolicies.cmd'
$scriptsIniPath = Join-Path $scriptsRoot 'scripts.ini'
$legacyPowerShellScriptsIniPath = Join-Path $scriptsRoot 'psscripts.ini'
$scriptsIni = @"
[Startup]
0CmdLine=Start-SguLocalProfileSecurityPolicies.cmd
0Parameters=
"@
$normalizedScriptsIni = $scriptsIni.TrimEnd("`r", "`n")
$launcherContents = @"
@echo off
"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "%~dp0Set-SguLocalProfileSecurityPolicies.ps1" -RunAsSystem
exit /b %ERRORLEVEL%
"@
$normalizedLauncherContents = $launcherContents.TrimEnd("`r", "`n")
$legacyManagedPowerShellScriptsIni = @"
[Startup]
0CmdLine=Set-SguLocalProfileSecurityPolicies.ps1
0Parameters=-RunAsSystem
"@.TrimEnd("`r", "`n")
# These are the Script CSE and its Group Policy editor snap-in. Domain
# clients ignore scripts.ini unless this CSE pair is on the GPO object.
$startupScriptExtension = '[{42B5FAAE-6536-11D2-AE5A-0000F87571E3}{40B66650-4972-11D1-A7CA-0000F87571E3}]'
# gPCMachineExtensionNames is a single concatenated AD attribute, even
# though it holds several CSE/snap-in GUID pairs.
$extensionValue = [string]($gpoAd.gPCMachineExtensionNames -join '')
$needsExtension = $extensionValue -notmatch [regex]::Escape($startupScriptExtension)
$needsScript = -not (Test-Path -LiteralPath $destinationScript -PathType Leaf)
if (-not $needsScript) {
$needsScript = (Get-FileHash -LiteralPath $SourceScript -Algorithm SHA256).Hash -ne
(Get-FileHash -LiteralPath $destinationScript -Algorithm SHA256).Hash
}
$needsIni = -not (Test-Path -LiteralPath $scriptsIniPath -PathType Leaf) -or
(Get-Content -LiteralPath $scriptsIniPath -Raw).TrimEnd("`r", "`n") -ne $normalizedScriptsIni
$needsLauncher = -not (Test-Path -LiteralPath $startupLauncher -PathType Leaf) -or
(Get-Content -LiteralPath $startupLauncher -Raw).TrimEnd("`r", "`n") -ne $normalizedLauncherContents
$removeLegacyPowerShellScriptsIni = (Test-Path -LiteralPath $legacyPowerShellScriptsIniPath -PathType Leaf) -and
(Get-Content -LiteralPath $legacyPowerShellScriptsIniPath -Raw).TrimEnd("`r", "`n") -eq $legacyManagedPowerShellScriptsIni
if ($needsScript -or $needsIni -or $needsLauncher -or $needsExtension -or $removeLegacyPowerShellScriptsIni) {
New-Item -ItemType Directory -Path $startupRoot -Force | Out-Null
Copy-Item -LiteralPath $SourceScript -Destination $destinationScript -Force
Set-Content -LiteralPath $scriptsIniPath -Value $normalizedScriptsIni -Encoding ASCII -NoNewline
Set-Content -LiteralPath $startupLauncher -Value $normalizedLauncherContents -Encoding ASCII -NoNewline
if ($removeLegacyPowerShellScriptsIni) {
Remove-Item -LiteralPath $legacyPowerShellScriptsIniPath -Force
}
if ($needsExtension) {
$extensionValue += $startupScriptExtension
}
# A GPO is replicated as both its SYSVOL file tree and its AD object.
# Bump the computer-side version only after the files are ready, then
# publish the same version in AD so clients process this new startup
# script on their next boot.
$currentVersion = [int64]$gpoAd.versionNumber
$currentComputerVersion = $currentVersion -band 0xFFFF
if ($currentComputerVersion -ge 65535) {
throw 'The laboratory GPO computer version cannot be incremented further.'
}
$nextVersion = ($currentVersion -band 0xFFFF0000) -bor ($currentComputerVersion + 1)
$gptIniPath = Join-Path $gpoAd.gPCFileSysPath 'gpt.ini'
$gptIni = Get-Content -LiteralPath $gptIniPath -Raw
$gptIni = [regex]::Replace($gptIni, '(?m)^Version=\d+\s*$', "Version=$nextVersion")
Set-Content -LiteralPath $gptIniPath -Value $gptIni -Encoding ASCII
# Set-ADObject validates a -Replace hashtable as one value type, so
# update the extension string and integer version in separate writes.
Set-ADObject -Identity $gpoAd.DistinguishedName -Server $DomainController -Replace @{
gPCMachineExtensionNames = $extensionValue
}
Set-ADObject -Identity $gpoAd.DistinguishedName -Server $DomainController -Replace @{
versionNumber = $nextVersion
}
}
$verifiedGpoAd = Get-ADObject -Identity $gpoAdPath -Properties gPCMachineExtensionNames `
-Server $DomainController -ErrorAction Stop
if ([string]($verifiedGpoAd.gPCMachineExtensionNames -join '') -notmatch [regex]::Escape($startupScriptExtension) -or
-not (Test-Path -LiteralPath $destinationScript -PathType Leaf) -or
-not (Test-Path -LiteralPath $startupLauncher -PathType Leaf) -or
(Get-Content -LiteralPath $scriptsIniPath -Raw).TrimEnd("`r", "`n") -ne $normalizedScriptsIni -or
(Get-Content -LiteralPath $startupLauncher -Raw).TrimEnd("`r", "`n") -ne $normalizedLauncherContents) {
throw 'The laboratory local-profile startup policy was not configured correctly.'
}
return [pscustomobject]@{
Configured = $true
Script = $destinationScript
RunsAs = 'LocalSystem'
}
}
if (-not $PSCmdlet.ShouldProcess($TargetOuDn, "Apply '$GpoName' with enforced loopback Merge")) { if (-not $PSCmdlet.ShouldProcess($TargetOuDn, "Apply '$GpoName' with enforced loopback Merge")) {
return return
} }
@@ -67,6 +180,8 @@ foreach ($setting in $settings) {
throw "Wallpaper policy verification failed for $($setting.Name)." throw "Wallpaper policy verification failed for $($setting.Name)."
} }
} }
$startupPolicy = Set-SguLocalProfilePolicyStartupScript -Gpo $gpo -DomainName $domainName `
-DomainController $DomainController -SourceScript $LocalProfilePolicyScriptPath
[pscustomobject]@{ [pscustomobject]@{
Name = $gpo.DisplayName Name = $gpo.DisplayName
Id = $gpo.Id Id = $gpo.Id
@@ -74,6 +189,8 @@ foreach ($setting in $settings) {
WallpaperPath = $WallpaperPath WallpaperPath = $WallpaperPath
Loopback = 'Merge' Loopback = 'Merge'
DisableLockWorkstationForAllUsers = $true DisableLockWorkstationForAllUsers = $true
LocalProfileStartupPolicy = $startupPolicy.Configured
LocalProfileStartupScript = $startupPolicy.Script
Enforced = $true Enforced = $true
BackupPath = $backupPath BackupPath = $backupPath
} }
@@ -0,0 +1,249 @@
#Requires -Version 5.1
[CmdletBinding(SupportsShouldProcess)]
param(
[switch]$RunAsSystem,
[string]$StatePath = "$env:ProgramData\SGU\Enrollment\local-profile-security-policy.json"
)
$ErrorActionPreference = 'Stop'
$policyRelativePath = 'Software\Microsoft\Windows\CurrentVersion\Policies\System'
$policyValueName = 'DisableLockWorkstation'
$systemSid = 'S-1-5-18'
function Test-SguRunningAsSystem {
$currentSid = [Security.Principal.WindowsIdentity]::GetCurrent().User.Value
return $currentSid -eq $systemSid
}
function Set-SguRegistryDword {
param(
[Parameter(Mandatory)][string]$RegistryPath,
[Parameter(Mandatory)][string]$Name,
[Parameter(Mandatory)][int]$Value
)
New-Item -Path $RegistryPath -Force | Out-Null
New-ItemProperty -Path $RegistryPath -Name $Name -PropertyType DWord -Value $Value -Force | Out-Null
$actual = Get-ItemPropertyValue -Path $RegistryPath -Name $Name -ErrorAction Stop
if ([int]$actual -ne $Value) {
throw "Could not set $Name to $Value in $RegistryPath."
}
}
function Set-SguRegHiveDword {
param(
[Parameter(Mandatory)][string]$Hive,
[Parameter(Mandatory)][string]$Name,
[Parameter(Mandatory)][int]$Value
)
# Do not use the PowerShell registry provider against an offline NTUSER.DAT
# hive. It can retain a registry-key handle until the runspace exits, which
# prevents reg.exe from unloading that hive. reg.exe opens and closes its
# own handle before returning.
$key = "$Hive\$policyRelativePath"
& reg.exe add $key /v $Name /t REG_DWORD /d $Value /f | Out-Null
if ($LASTEXITCODE -ne 0) {
throw "Could not set $Name in offline hive $Hive (exit code $LASTEXITCODE)."
}
$verification = (& reg.exe query $key /v $Name) -join [Environment]::NewLine
if ($LASTEXITCODE -ne 0 -or ($verification -notmatch "\b$Name\b\s+REG_DWORD\s+0x0*1\b")) {
throw "Could not verify $Name in offline hive $Hive."
}
}
function Invoke-SguProfileHivePolicy {
param(
[Parameter(Mandatory)]$Profile,
[Parameter(Mandatory)][string]$HiveName
)
$profilePath = [string]$Profile.LocalPath
$ntUserDat = Join-Path $profilePath 'NTUSER.DAT'
if (-not (Test-Path -LiteralPath $ntUserDat -PathType Leaf)) {
return [pscustomobject]@{
UserName = Split-Path $profilePath -Leaf
Sid = [string]$Profile.SID
LocalPath = $profilePath
Status = 'SkippedNoHive'
DisableLockWorkstation = $false
}
}
$userName = Split-Path $profilePath -Leaf
$loadedHivePath = "Registry::HKEY_USERS\$($Profile.SID)"
if ($Profile.Loaded -and (Test-Path -LiteralPath $loadedHivePath)) {
Set-SguRegistryDword -RegistryPath (Join-Path $loadedHivePath $policyRelativePath) `
-Name $policyValueName -Value 1
return [pscustomobject]@{
UserName = $userName
Sid = [string]$Profile.SID
LocalPath = $profilePath
Status = 'UpdatedLoadedHive'
DisableLockWorkstation = $true
}
}
$regHive = "HKU\$HiveName"
& reg.exe load $regHive $ntUserDat | Out-Null
if ($LASTEXITCODE -ne 0) {
throw "Unable to load the local profile hive for '$userName' (exit code $LASTEXITCODE)."
}
try {
Set-SguRegHiveDword -Hive $regHive -Name $policyValueName -Value 1
}
finally {
& reg.exe unload $regHive | Out-Null
if ($LASTEXITCODE -ne 0) {
throw "Unable to unload the local profile hive for '$userName' (exit code $LASTEXITCODE)."
}
}
[pscustomobject]@{
UserName = $userName
Sid = [string]$Profile.SID
LocalPath = $profilePath
Status = 'UpdatedUnloadedHive'
DisableLockWorkstation = $true
}
}
function Invoke-SguDefaultProfilePolicy {
$defaultProfile = Join-Path $env:SystemDrive 'Users\Default\NTUSER.DAT'
if (-not (Test-Path -LiteralPath $defaultProfile -PathType Leaf)) {
throw "The default user hive was not found at $defaultProfile."
}
$hiveName = 'SGU-DefaultProfile-' + [guid]::NewGuid().ToString('N')
$regHive = "HKU\$hiveName"
& reg.exe load $regHive $defaultProfile | Out-Null
if ($LASTEXITCODE -ne 0) {
throw "Unable to load the default user hive (exit code $LASTEXITCODE)."
}
try {
Set-SguRegHiveDword -Hive $regHive -Name $policyValueName -Value 1
}
finally {
& reg.exe unload $regHive | Out-Null
if ($LASTEXITCODE -ne 0) {
throw "Unable to unload the default user hive (exit code $LASTEXITCODE)."
}
}
}
function Invoke-SguSystemWorker {
param(
[Parameter(Mandatory)][string]$ScriptPath,
[Parameter(Mandatory)][string]$ResultPath
)
$taskName = 'SGU-ApplyLocalProfileSecurity-' + [guid]::NewGuid().ToString('N')
$powerShellPath = Join-Path $env:SystemRoot 'System32\WindowsPowerShell\v1.0\powershell.exe'
$escapedScriptPath = $ScriptPath.Replace("'", "''")
$escapedResultPath = $ResultPath.Replace("'", "''")
# Task Scheduler does not apply PowerShell quoting rules to a -File command
# line consistently. An encoded command makes the SYSTEM hand-off reliable
# even when the enrollment directory contains spaces.
$workerCommand = "& '$escapedScriptPath' -RunAsSystem -StatePath '$escapedResultPath'"
$encodedWorkerCommand = [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($workerCommand))
$arguments = "-NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand $encodedWorkerCommand"
$action = New-ScheduledTaskAction -Execute $powerShellPath -Argument $arguments
$principal = New-ScheduledTaskPrincipal -UserId 'SYSTEM' -LogonType ServiceAccount -RunLevel Highest
try {
Register-ScheduledTask -TaskName $taskName -Action $action -Principal $principal -Force | Out-Null
Start-ScheduledTask -TaskName $taskName
$deadline = (Get-Date).AddMinutes(2)
do {
Start-Sleep -Milliseconds 400
$task = Get-ScheduledTask -TaskName $taskName -ErrorAction Stop
} while ($task.State -eq 'Running' -and (Get-Date) -lt $deadline)
$taskInfo = Get-ScheduledTaskInfo -TaskName $taskName -ErrorAction Stop
if ($task.State -eq 'Running') {
throw 'The temporary SYSTEM policy worker did not finish within two minutes.'
}
if (-not (Test-Path -LiteralPath $ResultPath -PathType Leaf)) {
if ($taskInfo.LastTaskResult -ne 0) {
throw "The temporary SYSTEM policy worker failed with exit code $($taskInfo.LastTaskResult) and did not write its verification state."
}
throw 'The SYSTEM policy worker completed without writing its verification state.'
}
$result = Get-Content -LiteralPath $ResultPath -Raw | ConvertFrom-Json
if ($taskInfo.LastTaskResult -ne 0) {
$failureDetail = if ($result.Error) { ": $($result.Error)" } else { '' }
throw "The temporary SYSTEM policy worker failed with exit code $($taskInfo.LastTaskResult)$failureDetail"
}
if (-not $result.IsValid) {
throw 'The SYSTEM policy worker did not verify every local user profile.'
}
return $result
}
finally {
Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction SilentlyContinue
}
}
$identity = [Security.Principal.WindowsIdentity]::GetCurrent()
$principal = [Security.Principal.WindowsPrincipal]::new($identity)
if (-not $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
throw 'Run this script from an elevated Windows PowerShell session.'
}
if ($RunAsSystem -and -not (Test-SguRunningAsSystem)) {
throw '-RunAsSystem is reserved for the temporary SYSTEM policy worker.'
}
$stateDirectory = Split-Path -Path $StatePath -Parent
if (-not $RunAsSystem) {
if (-not $PSCmdlet.ShouldProcess($env:COMPUTERNAME, 'Apply DisableLockWorkstation to every local user profile')) {
return
}
New-Item -ItemType Directory -Path $stateDirectory -Force | Out-Null
$workerResult = Invoke-SguSystemWorker -ScriptPath $PSCommandPath -ResultPath $StatePath
return [pscustomobject]$workerResult
}
New-Item -ItemType Directory -Path $stateDirectory -Force | Out-Null
$profileResults = [Collections.Generic.List[object]]::new()
$defaultProfileConfigured = $false
$failure = $null
try {
$localSids = @(Get-LocalUser | ForEach-Object { $_.SID.Value })
$localProfiles = @(Get-CimInstance Win32_UserProfile | Where-Object {
-not $_.Special -and $localSids -contains $_.SID
})
$counter = 0
foreach ($profile in $localProfiles) {
$counter++
$hiveName = 'SGU-LocalProfile-{0}-{1}' -f $counter, [guid]::NewGuid().ToString('N')
$profileResults.Add((Invoke-SguProfileHivePolicy -Profile $profile -HiveName $hiveName))
}
Invoke-SguDefaultProfilePolicy
$defaultProfileConfigured = $true
}
catch {
$failure = $_.Exception.Message
}
$failedProfiles = @($profileResults | Where-Object { -not $_.DisableLockWorkstation })
$result = [pscustomobject]@{
ComputerName = $env:COMPUTERNAME
GeneratedAt = (Get-Date).ToString('o')
IsValid = ([string]::IsNullOrWhiteSpace($failure) -and $defaultProfileConfigured -and $failedProfiles.Count -eq 0)
PolicyName = $policyValueName
PolicyValue = 1
LocalProfiles = @($profileResults)
DefaultProfileConfigured = $defaultProfileConfigured
Error = $failure
}
$result | ConvertTo-Json -Depth 5 | Set-Content -LiteralPath $StatePath -Encoding UTF8
if (-not $result.IsValid) {
$failureMessage = if ($failure) {
$failure
}
else {
'DisableLockWorkstation could not be applied to every local user profile.'
}
throw $failureMessage
}
[pscustomobject]$result
+11
View File
@@ -124,10 +124,21 @@ if (-not $verifiedPasswordNeverExpires) {
throw "The local account '$userName' password is not configured to never expire." throw "The local account '$userName' password is not configured to never expire."
} }
$localProfilePolicyScript = Join-Path $PSScriptRoot 'Set-SguLocalProfileSecurityPolicies.ps1'
if (-not (Test-Path -LiteralPath $localProfilePolicyScript -PathType Leaf)) {
throw 'Set-SguLocalProfileSecurityPolicies.ps1 must be beside Set-SguStandardLocalUser.ps1.'
}
$localProfilePolicy = & $localProfilePolicyScript
if (-not $localProfilePolicy.IsValid) {
throw 'The local profile security policy did not reach every local user profile.'
}
[pscustomobject]@{ [pscustomobject]@{
UserName = $verifiedUser.Name UserName = $verifiedUser.Name
Enabled = $verifiedUser.Enabled Enabled = $verifiedUser.Enabled
IsAdministrator = $false IsAdministrator = $false
IsStandardUser = $true IsStandardUser = $true
PasswordNeverExpires = $verifiedPasswordNeverExpires PasswordNeverExpires = $verifiedPasswordNeverExpires
DisableLockWorkstationForAllLocalProfiles = [bool]$localProfilePolicy.IsValid
LocalProfilesSecured = @($localProfilePolicy.LocalProfiles).Count
} }
+16
View File
@@ -18,6 +18,7 @@ $classRegistryPath = "HKLM:\SOFTWARE\Classes\CLSID\$providerClassId\InprocServer
$defaultProviderPolicyPath = 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\System' $defaultProviderPolicyPath = 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\System'
$interactiveLogonPolicyPath = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System' $interactiveLogonPolicyPath = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System'
$settingsPath = Join-Path $env:ProgramData 'SGU\CredentialProvider\settings.json' $settingsPath = Join-Path $env:ProgramData 'SGU\CredentialProvider\settings.json'
$localProfilePolicyStatePath = Join-Path $env:ProgramData 'SGU\Enrollment\local-profile-security-policy.json'
$issues = [Collections.Generic.List[string]]::new() $issues = [Collections.Generic.List[string]]::new()
$standardLocalUserName = 'alumno' $standardLocalUserName = 'alumno'
$passwordNeverExpiresFlag = 0x10000 $passwordNeverExpiresFlag = 0x10000
@@ -120,6 +121,20 @@ if (-not $localUserEnumerationDisabled) {
$issues.Add('Local user enumeration is not explicitly disabled for the domain client.') $issues.Add('Local user enumeration is not explicitly disabled for the domain client.')
} }
$localProfileLockingConfigured = $false
try {
$localProfilePolicyState = Get-Content -LiteralPath $localProfilePolicyStatePath -Raw | ConvertFrom-Json
$localProfileLockingConfigured = [bool]$localProfilePolicyState.IsValid -and
[bool]$localProfilePolicyState.DefaultProfileConfigured -and
@($localProfilePolicyState.LocalProfiles | Where-Object { -not $_.DisableLockWorkstation }).Count -eq 0
}
catch {
# The enrollment report below identifies the absent system-worker verification state.
}
if (-not $localProfileLockingConfigured) {
$issues.Add('DisableLockWorkstation is not configured for every local user profile and the default profile.')
}
$passwordProviderPreserved = Test-Path -LiteralPath $passwordProviderRegistryPath $passwordProviderPreserved = Test-Path -LiteralPath $passwordProviderRegistryPath
if (-not $passwordProviderPreserved) { if (-not $passwordProviderPreserved) {
$issues.Add('The built-in Microsoft password provider registration is missing.') $issues.Add('The built-in Microsoft password provider registration is missing.')
@@ -295,6 +310,7 @@ $result = [pscustomobject]@{
LastSignedInUserHidden = $lastSignedInUserHidden LastSignedInUserHidden = $lastSignedInUserHidden
FastUserSwitchingHidden = $fastUserSwitchingHidden FastUserSwitchingHidden = $fastUserSwitchingHidden
LocalUserEnumerationDisabled = $localUserEnumerationDisabled LocalUserEnumerationDisabled = $localUserEnumerationDisabled
LocalProfileLockingConfigured = $localProfileLockingConfigured
PasswordProviderPreserved = $passwordProviderPreserved PasswordProviderPreserved = $passwordProviderPreserved
StandardLocalUserPresent = $standardLocalUserPresent StandardLocalUserPresent = $standardLocalUserPresent
StandardLocalUserEnabled = $standardLocalUserEnabled StandardLocalUserEnabled = $standardLocalUserEnabled
+1 -1
View File
@@ -161,7 +161,7 @@ app.MapPost("/v1/authenticate", async (
AuthenticationFlowOutcome.InvalidCredentials => Results.Json( AuthenticationFlowOutcome.InvalidCredentials => Results.Json(
new ErrorResponse( new ErrorResponse(
result.ErrorCode ?? "INVALID_INSTITUTIONAL_CREDENTIALS", result.ErrorCode ?? "INVALID_INSTITUTIONAL_CREDENTIALS",
"Credenciales institucionales inválidas."), "Usuario o contraseña incorrectos."),
statusCode: StatusCodes.Status401Unauthorized), statusCode: StatusCodes.Status401Unauthorized),
_ => Unavailable(context, result.ErrorCode) _ => Unavailable(context, result.ErrorCode)
@@ -16,12 +16,12 @@ public sealed class SguCredentialProvider : CredentialProviderBase
{ {
yield return new CredentialProviderLabelControl( yield return new CredentialProviderLabelControl(
ControlKeys.ProviderLabel, ControlKeys.ProviderLabel,
"La Salle · Acceso SGU"); "Acceso Institucional");
yield return new CredentialProviderLogoControl( yield return new CredentialProviderLogoControl(
ControlKeys.ProviderLogo, ControlKeys.ProviderLogo,
"Acceso institucional SGU", "Acceso Institucional",
ProviderTileIcon.Create()); ProviderTileIcon.Create());
yield return new LargeLabelControl(ControlKeys.Heading, "Acceso institucional SGU") yield return new LargeLabelControl(ControlKeys.Heading, "Iniciar sesión")
{ {
// Isolate the CPFT_LARGE_TEXT heading from the compact provider tile // Isolate the CPFT_LARGE_TEXT heading from the compact provider tile
// for the selected-layout variant. LogonUI still owns the typography. // for the selected-layout variant. LogonUI still owns the typography.
@@ -29,8 +29,8 @@ public sealed class SguCredentialProvider : CredentialProviderBase
}; };
yield return new SmallLabelControl( yield return new SmallLabelControl(
ControlKeys.InformationLabel, ControlKeys.InformationLabel,
"Usa tu clave institucional (DO, AL o AD + 6 dígitos) y contraseña."); "Escribe tu usuario institucional o de dominio y contraseña.");
yield return new TextboxControl(ControlKeys.UserName, "Clave institucional"); yield return new TextboxControl(ControlKeys.UserName, "Usuario");
SecurePasswordTextboxControl password = new(ControlKeys.Password, "Contraseña"); SecurePasswordTextboxControl password = new(ControlKeys.Password, "Contraseña");
yield return password; yield return password;
yield return new SubmitButtonControl(ControlKeys.Submit, "Iniciar sesión", password); yield return new SubmitButtonControl(ControlKeys.Submit, "Iniciar sesión", password);
+72 -24
View File
@@ -34,9 +34,14 @@ internal sealed class SguCredentialTile : CredentialTile3
protected override CredentialResponseBase GetCredentials() protected override CredentialResponseBase GetCredentials()
{ {
if (!UserIdentityClassifier.TryParse(userNameControl.Text, out UserIdentity? identity) || identity is null) ProviderSettings settings = TryLoadDomainOnlySettings();
if (!TryGetWindowsLogonName(
userNameControl.Text,
settings.DomainNetbios,
out string domain,
out string userName))
{ {
return Failure("La clave debe usar DO, AL o AD seguido de seis dígitos."); return Failure("Escribe un usuario válido.");
} }
SecureString securePassword = passwordControl.Password; SecureString securePassword = passwordControl.Password;
@@ -45,10 +50,16 @@ internal sealed class SguCredentialTile : CredentialTile3
return Failure("La contraseña es requerida."); return Failure("La contraseña es requerida.");
} }
// Ordinary Active Directory accounts go straight to Windows. Only an
// institutional key needs SGU validation and the account UPSERT.
if (!UserIdentityClassifier.TryParse(userNameControl.Text, out UserIdentity? identity) || identity is null)
{
return DomainCredential(domain, userName, securePassword);
}
string plainTextPassword = CopyToManagedString(securePassword); string plainTextPassword = CopyToManagedString(securePassword);
try try
{ {
ProviderSettings settings;
BrokerDecision decision; BrokerDecision decision;
try try
{ {
@@ -61,33 +72,25 @@ internal sealed class SguCredentialTile : CredentialTile3
} }
catch catch
{ {
settings = TryLoadDomainOnlySettings();
decision = BrokerDecision.Unavailable("LOCAL_CONFIGURATION_OR_TLS_ERROR"); decision = BrokerDecision.Unavailable("LOCAL_CONFIGURATION_OR_TLS_ERROR");
} }
if (decision.Kind == BrokerDecisionKind.InvalidCredentials) if (decision.Kind == BrokerDecisionKind.Authorized)
{ {
return Failure("Credenciales institucionales inválidas."); return DomainCredential(decision.Domain!, decision.UserName!, securePassword);
} }
string domain = decision.Kind == BrokerDecisionKind.Authorized // An SGU rejection does not create an account. Pass the unchanged
? decision.Domain! // credential to Windows so an existing AD account with the same
: settings.DomainNetbios; // name can still authenticate. A non-existent account is rejected
string userName = decision.Kind == BrokerDecisionKind.Authorized // by the domain controller.
? decision.UserName! return DomainCredential(
: identity.UserName; domain,
userName,
return new CredentialResponseSecure securePassword,
{ decision.Kind == BrokerDecisionKind.Unavailable
IsSuccess = true, ? "El servicio SGU no está disponible; Windows validará la contraseña guardada en el dominio."
StatusIcon = decision.Kind == BrokerDecisionKind.Unavailable ? StatusIcon.Warning : StatusIcon.None, : null);
StatusText = decision.Kind == BrokerDecisionKind.Unavailable
? "Servicio institucional no disponible; Windows validará la última contraseña de dominio registrada."
: null,
Domain = domain,
Username = userName,
Password = securePassword
};
} }
finally finally
{ {
@@ -111,6 +114,51 @@ internal sealed class SguCredentialTile : CredentialTile3
} }
} }
private static bool TryGetWindowsLogonName(
string? enteredName,
string defaultDomain,
out string domain,
out string userName)
{
domain = string.Empty;
userName = enteredName?.Trim() ?? string.Empty;
if (userName.Length is 0 or > 256 || userName.Any(char.IsControl))
{
return false;
}
int slash = userName.LastIndexOf('\\');
if (slash >= 0)
{
domain = userName[..slash];
userName = userName[(slash + 1)..];
if (domain.Length is 0 or > 256 || domain.Contains('\\') || userName.Length == 0)
{
return false;
}
}
else if (!userName.Contains('@'))
{
domain = defaultDomain;
}
return userName.Length > 0 && domain.Length <= 256 && !domain.Any(char.IsControl);
}
private static CredentialResponseSecure DomainCredential(
string domain,
string userName,
SecureString password,
string? statusText = null) => new()
{
IsSuccess = true,
StatusIcon = statusText is null ? StatusIcon.None : StatusIcon.Warning,
StatusText = statusText,
Domain = domain,
Username = userName,
Password = password
};
private static CredentialResponseSecure Failure(string message) => new() private static CredentialResponseSecure Failure(string message) => new()
{ {
IsSuccess = false, IsSuccess = false,
+28
View File
@@ -1,5 +1,6 @@
$repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path $repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
$localUserScriptPath = Join-Path $repositoryRoot 'scripts\Set-SguStandardLocalUser.ps1' $localUserScriptPath = Join-Path $repositoryRoot 'scripts\Set-SguStandardLocalUser.ps1'
$localProfilePolicyScriptPath = Join-Path $repositoryRoot 'scripts\Set-SguLocalProfileSecurityPolicies.ps1'
$enrollmentTestScriptPath = Join-Path $repositoryRoot 'scripts\Test-SguClientEnrollment.ps1' $enrollmentTestScriptPath = Join-Path $repositoryRoot 'scripts\Test-SguClientEnrollment.ps1'
$packageScriptPath = Join-Path $repositoryRoot 'scripts\New-SguBootstrapPackages.ps1' $packageScriptPath = Join-Path $repositoryRoot 'scripts\New-SguBootstrapPackages.ps1'
$releaseScriptPath = Join-Path $repositoryRoot 'scripts\Publish-GiteaRelease.ps1' $releaseScriptPath = Join-Path $repositoryRoot 'scripts\Publish-GiteaRelease.ps1'
@@ -17,6 +18,16 @@ if ($parseErrors.Count -gt 0) {
throw ($parseErrors -join [Environment]::NewLine) throw ($parseErrors -join [Environment]::NewLine)
} }
$localProfilePolicyTokens = $null
$localProfilePolicyParseErrors = $null
[void][Management.Automation.Language.Parser]::ParseFile(
$localProfilePolicyScriptPath,
[ref]$localProfilePolicyTokens,
[ref]$localProfilePolicyParseErrors)
if ($localProfilePolicyParseErrors.Count -gt 0) {
throw ($localProfilePolicyParseErrors -join [Environment]::NewLine)
}
$descriptionAssignment = $scriptAst.Find({ $descriptionAssignment = $scriptAst.Find({
param($node) param($node)
$node -is [Management.Automation.Language.AssignmentStatementAst] -and $node -is [Management.Automation.Language.AssignmentStatementAst] -and
@@ -55,6 +66,23 @@ Describe 'SGU Windows client enrollment scripts' {
}).Count | Should Be 0 }).Count | Should Be 0
} }
It 'applies DisableLockWorkstation to existing and future local users during enrollment' {
$localUserSource = Get-Content -LiteralPath $localUserScriptPath -Raw
$profilePolicySource = Get-Content -LiteralPath $localProfilePolicyScriptPath -Raw
$enrollmentSource = Get-Content -LiteralPath (Join-Path $repositoryRoot 'scripts\Enroll-SguDomainClient.ps1') -Raw
$packageSource = Get-Content -LiteralPath $packageScriptPath -Raw
$localUserSource | Should Match 'Set-SguLocalProfileSecurityPolicies\.ps1'
$profilePolicySource | Should Match "\$policyValueName = 'DisableLockWorkstation'"
$profilePolicySource | Should Match 'Get-LocalUser'
$profilePolicySource | Should Match 'NTUSER\.DAT'
$profilePolicySource | Should Match "-UserId 'SYSTEM'"
$profilePolicySource | Should Match 'Unregister-ScheduledTask'
$profilePolicySource | Should Match 'DefaultProfileConfigured'
$enrollmentSource | Should Match "'Set-SguLocalProfileSecurityPolicies\.ps1'"
$packageSource | Should Match "'Set-SguLocalProfileSecurityPolicies\.ps1'"
}
It 'publishes one Windows artifact with automatic compatibility' { It 'publishes one Windows artifact with automatic compatibility' {
$packageSource = Get-Content -LiteralPath $packageScriptPath -Raw $packageSource = Get-Content -LiteralPath $packageScriptPath -Raw
$releaseSource = Get-Content -LiteralPath $releaseScriptPath -Raw $releaseSource = Get-Content -LiteralPath $releaseScriptPath -Raw
@@ -28,6 +28,14 @@ Describe 'Laboratorio wallpaper policy packaging and scope' {
$policySource | Should Match 'local accounts such as \.\\ing' $policySource | Should Match 'local accounts such as \.\\ing'
$policySource | Should Match 'DisableLockWorkstationForAllUsers = \$true' $policySource | Should Match 'DisableLockWorkstationForAllUsers = \$true'
} }
It 'runs the local-profile lock restriction as LocalSystem at computer startup' {
$policySource | Should Match 'Set-SguLocalProfileSecurityPolicies\.ps1'
$policySource | Should Match 'Join-Path \$scriptsRoot ''scripts\.ini'''
$policySource | Should Match 'Start-SguLocalProfileSecurityPolicies\.cmd'
$policySource | Should Match '-ExecutionPolicy Bypass'
$policySource | Should Match "RunsAs = 'LocalSystem'"
$policySource | Should Match 'gPCMachineExtensionNames'
}
It 'reuses and backs up an existing GPO and verifies the result' { It 'reuses and backs up an existing GPO and verifies the result' {
foreach ($command in @('Get-GPO', 'Backup-GPO', 'Set-GPLink', 'New-GPLink', 'Get-GPRegistryValue')) { foreach ($command in @('Get-GPO', 'Backup-GPO', 'Set-GPLink', 'New-GPLink', 'Get-GPRegistryValue')) {
$policySource | Should Match ([regex]::Escape($command)) $policySource | Should Match ([regex]::Escape($command))
@@ -69,6 +69,29 @@ public sealed class AuthenticationWorkflowTests
Assert.Null(directory.Password); Assert.Null(directory.Password);
} }
[Fact]
public async Task EverySuccessfulSignInSynchronizesTheLatestPassword()
{
CapturingDirectorySynchronizer directory = new();
AuthenticationWorkflow workflow = new(
new CapturingNtlmValidator(NtlmValidationResult.Valid()),
directory);
_ = await workflow.AuthenticateAsync(
"AL123456",
"Contraseña-anterior-27!",
TestContext.Current.CancellationToken);
AuthenticationFlowResult result = await workflow.AuthenticateAsync(
"AL123456",
"Contraseña-nueva-28!",
TestContext.Current.CancellationToken);
Assert.Equal(AuthenticationFlowOutcome.Authorized, result.Outcome);
Assert.Equal(
["Contraseña-anterior-27!", "Contraseña-nueva-28!"],
directory.Passwords);
}
private sealed class CapturingNtlmValidator(NtlmValidationResult result) : INtlmCredentialValidator private sealed class CapturingNtlmValidator(NtlmValidationResult result) : INtlmCredentialValidator
{ {
public UserIdentity? Identity { get; private set; } public UserIdentity? Identity { get; private set; }
@@ -92,6 +115,8 @@ public sealed class AuthenticationWorkflowTests
public string? Password { get; private set; } public string? Password { get; private set; }
public List<string> Passwords { get; } = [];
public InstitutionalProfile? Profile { get; private set; } public InstitutionalProfile? Profile { get; private set; }
public Task<DirectorySyncResult> SynchronizeAsync( public Task<DirectorySyncResult> SynchronizeAsync(
@@ -103,6 +128,7 @@ public sealed class AuthenticationWorkflowTests
Identity = identity; Identity = identity;
Profile = profile; Profile = profile;
Password = password; Password = password;
Passwords.Add(password);
return Task.FromResult(new DirectorySyncResult( return Task.FromResult(new DirectorySyncResult(
"LCI", "LCI",
identity.UserName, identity.UserName,
@@ -14,11 +14,11 @@ internal static class Program
private static readonly string[] ExpectedLabels = private static readonly string[] ExpectedLabels =
[ [
"La Salle · Acceso SGU", "Acceso Institucional",
"Acceso institucional SGU", "Acceso Institucional",
"Acceso institucional SGU", "Iniciar sesión",
"Usa tu clave institucional (DO, AL o AD + 6 dígitos) y contraseña.", "Escribe tu usuario institucional o de dominio y contraseña.",
"Clave institucional", "Usuario",
"Contraseña", "Contraseña",
"Iniciar sesión" "Iniciar sesión"
]; ];
@@ -146,7 +146,7 @@ internal static class Program
private static int RunSerializationProbe(string mode, IntPtr credential, IReadOnlyList<string> labels) private static int RunSerializationProbe(string mode, IntPtr credential, IReadOnlyList<string> labels)
{ {
string[] labelArray = labels.ToArray(); string[] labelArray = labels.ToArray();
uint userNameFieldId = checked((uint)Array.IndexOf(labelArray, "Clave institucional")); uint userNameFieldId = checked((uint)Array.IndexOf(labelArray, "Usuario"));
uint passwordFieldId = checked((uint)Array.IndexOf(labelArray, "Contraseña")); uint passwordFieldId = checked((uint)Array.IndexOf(labelArray, "Contraseña"));
string userName = mode == "online-success" string userName = mode == "online-success"
? Environment.GetEnvironmentVariable("SGU_TEST_USERNAME") ? Environment.GetEnvironmentVariable("SGU_TEST_USERNAME")
@@ -184,7 +184,7 @@ internal static class Program
bool rejectionPassed = response == (int)SerializationResponse.NoCredentialNotFinished && bool rejectionPassed = response == (int)SerializationResponse.NoCredentialNotFinished &&
serialization.SerializationData == IntPtr.Zero && serialization.SerializationData == IntPtr.Zero &&
statusIcon == (int)StatusIcon.Error && statusIcon == (int)StatusIcon.Error &&
statusText == "Credenciales institucionales inválidas."; statusText == "Usuario o contraseña incorrectos.";
Console.WriteLine(JsonSerializer.Serialize(new Console.WriteLine(JsonSerializer.Serialize(new
{ {
passed = rejectionPassed, passed = rejectionPassed,
@@ -216,7 +216,7 @@ internal static class Program
? serializedCredentialPassed && statusIcon == (int)StatusIcon.None && string.IsNullOrEmpty(statusText) ? serializedCredentialPassed && statusIcon == (int)StatusIcon.None && string.IsNullOrEmpty(statusText)
: serializedCredentialPassed && : serializedCredentialPassed &&
statusIcon == (int)StatusIcon.Warning && statusIcon == (int)StatusIcon.Warning &&
statusText == "Servicio institucional no disponible; Windows validará la última contraseña de dominio registrada."; statusText == "El servicio de autenticación no está disponible; Windows validará la última contraseña de dominio registrada.";
Console.WriteLine(JsonSerializer.Serialize(new Console.WriteLine(JsonSerializer.Serialize(new
{ {
passed, passed,
@@ -55,8 +55,8 @@ public sealed class ProviderTileIconTests
LargeLabelControl heading = Assert.Single(controls.OfType<LargeLabelControl>()); LargeLabelControl heading = Assert.Single(controls.OfType<LargeLabelControl>());
SguCredentialTile tile = Assert.IsType<SguCredentialTile>(provider.CreateGenericTile()); SguCredentialTile tile = Assert.IsType<SguCredentialTile>(provider.CreateGenericTile());
Assert.Equal("La Salle · Acceso SGU", providerLabel.Label); Assert.Equal("Acceso Institucional", providerLabel.Label);
Assert.Equal("Acceso institucional SGU", heading.Label); Assert.Equal("Iniciar sesión", heading.Label);
Assert.Equal(FieldState.DisplayInSelectedTile, heading.State); Assert.Equal(FieldState.DisplayInSelectedTile, heading.State);
Assert.Equal(GenericTileDisplayMode.DisplayAsDedicatedTile, tile.GenericTileDisplayMode); Assert.Equal(GenericTileDisplayMode.DisplayAsDedicatedTile, tile.GenericTileDisplayMode);
Assert.IsAssignableFrom<CredentialTile3>(tile); Assert.IsAssignableFrom<CredentialTile3>(tile);