Honor exact SGO passwords for managed domain users

This commit is contained in:
alexrg committed 2026-09-24 13:22:12 -06:00
1 parent 738df9ceea
commit 843a1956d6
11 files changed
+224 -19

No files matched your search

+10 -3
View File
@@ -67,9 +67,16 @@ 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.
SGU explicitly rejects the credential, the provider stops without trying AD.
If SGO accepts it but AD synchronization fails, the provider reports that
failure without trying a stale AD verifier. Only a genuine broker/SGO outage
uses the documented Windows cached-domain-credential fallback, for an existing
account. A matching username pattern alone never provisions an account.
The domain bootstrap creates a fine-grained password policy for the three SGU
role security groups. It allows the broker to record the exact password SGO
accepted, even when the normal domain complexity policy would reject it. It
does not relax password requirements for other domain accounts.
Before an account becomes usable, the broker applies explicit deny ACEs for the
Active Directory `Change Password` extended right to SELF and Everyone. Users
+19
View File
@@ -0,0 +1,19 @@
# v0.6.19 — SGO password authority
- Add a fine-grained Active Directory password policy scoped to the three
`SGU-*` role groups. A password accepted by SGO is stored unchanged in AD,
including short passwords that the default domain complexity policy rejects.
Other domain accounts keep their existing policy.
- Apply and verify this policy during server bootstrap. Existing SGU accounts
receive it through their role-group membership.
- Stop institutional login immediately when SGO explicitly rejects a password.
When SGO accepts it but AD synchronization fails, show a distinct error
instead of trying an older AD password.
- Preserve the documented cached-domain fallback only while the broker or SGO
is genuinely unavailable.
Operational validation: on the domain controller, disposable users in each of
`SGU-Alumnos`, `SGU-Administrativos`, and `SGU-Docentes` accepted a three-character
password and were removed after the test. The three originally reported
accounts still require a real SGO sign-in to finish AD provisioning; no student
password was requested or stored for testing.
+25 -5
View File
@@ -18,6 +18,14 @@ the same source list. RDP uses a separate allowlist. See
`Marshal.ZeroFreeGlobalAllocUnicode`; managed references are released as soon
as each request completes.
- 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 a password accepted by SGO is never altered or rejected
by AD. The default domain password policy remains unchanged. The group is
assigned before `SetPassword` for newly created users. Bootstrap reapplies
the policy via `Set-SguInstitutionalPasswordPolicy.ps1`.
- Managed `Usuarios-SGU` accounts deny the SELF and Everyone `Change Password`
extended right. Only an administrator or the broker through the separate
`Reset Password` right can replace the AD password.
@@ -89,13 +97,25 @@ Use an enterprise CA with revocation checking in production.
The provider distinguishes an SGU rejection from unavailable infrastructure:
- `400`/`401`: do not create or update the account; submit the unchanged
credential to Windows so an existing AD account can authenticate.
- `400`/`401`: do not create or update the account and do not submit a Windows
credential. An explicit SGO rejection is authoritative, including when an
older AD password still exists.
- `DIRECTORY_SYNCHRONIZATION_FAILED`: SGO accepted the password but AD did not
record it. Show a specific error and do not attempt Windows logon against a
potentially stale AD verifier.
- timeout, TLS/connectivity error, `429`, or `5xx`: submit the unchanged
credential to Windows. Windows must still validate it against AD or its cached
domain verifier, so this does not grant access without a domain credential.
credential to Windows only for a genuine broker/SGO outage. Windows must still
validate it against AD or its cached domain verifier, so this does not grant
access without a domain credential. This continuity path can accept a
last-known AD password while SGO is unreachable; decide explicitly whether
that availability trade-off is appropriate for each deployment.
- usernames that do not match the institutional key format go directly to
Windows and are never sent to SGU or provisioned by the broker.
Windows and are never sent to SGU or provisioned by the broker.
Allowing an SGO-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
password verifier duplicates attackable credential material, while a reversible
@@ -518,6 +518,7 @@ foreach ($requiredPath in @(
(Join-Path $scriptsRoot 'Deploy-AuthBroker.ps1'),
(Join-Path $scriptsRoot 'New-LabCertificate.ps1'),
(Join-Path $scriptsRoot 'Set-LabBrokerDns.ps1'),
(Join-Path $scriptsRoot 'Set-SguInstitutionalPasswordPolicy.ps1'),
(Join-Path $scriptsRoot 'Set-SguDomainComputerPolicies.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationRemoteAccess.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationAdministrators.ps1'),
@@ -774,6 +775,9 @@ if (Test-Path -LiteralPath $brokerConfigurationPath -PathType Leaf) {
-CreateMissingOus `
-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
# dynamic DNS registration was disabled.
$hostRecords = @(Get-DnsServerResourceRecord -ZoneName $DomainName `
@@ -1,12 +1,12 @@
[CmdletBinding(SupportsShouldProcess)]
param(
[string]$Version = '0.6.16',
[string]$Version = '0.6.19',
[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.19/sgu-windows-client-bootstrap-0.6.19.zip',
[ValidatePattern('^[0-9A-Fa-f]{64}$')]
[string]$ClientPackageSha256 = 'AFC40A87E83A6B27319792F575C384EBB175F42DCF670B7AB620A64C75ED499B',
[string]$ClientPackageSha256 = 'C1FA9C92BA941003FE54E9074973CF6630E30456B186C099E731EC5F54182F24',
[string]$GpoName = 'SGU - Credential Provider update',
+1
View File
@@ -227,6 +227,7 @@ $serverScripts = @(
'Register-SguClientCertificate.ps1',
'Register-SguRustDeskDevice.ps1',
'Set-LabBrokerDns.ps1',
'Set-SguInstitutionalPasswordPolicy.ps1',
'Set-SguDomainComputerPolicies.ps1',
'Set-SguLaboratorioWallpaperPolicy.ps1',
'Set-SguLocalProfileSecurityPolicies.ps1',
@@ -0,0 +1,106 @@
[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 SGO 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 'SGO validates the exact institutional password; 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
}
}
}
$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
MinPasswordLength = $policy.MinPasswordLength
PasswordHistoryCount = $policy.PasswordHistoryCount
MaxPasswordAge = $policy.MaxPasswordAge
Subjects = @($policy.AppliesTo)
}
+2 -1
View File
@@ -67,7 +67,8 @@ internal sealed class BrokerClient : IDisposable
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)
{
@@ -80,17 +80,27 @@ internal sealed class SguCredentialTile : CredentialTile3
return DomainCredential(decision.Domain!, decision.UserName!, securePassword);
}
// An SGU rejection does not create an account. Pass the unchanged
// credential to Windows so an existing AD account with the same
// name can still authenticate. A non-existent account is rejected
// by the domain controller.
// An explicit SGO rejection is authoritative even when an older AD
// verifier for the same institutional key still exists.
if (decision.Kind == BrokerDecisionKind.InvalidCredentials)
{
return Failure("Usuario o contraseña incorrectos.");
}
// SGO accepted this password but AD could not record it. Windows
// must not attempt a logon against a stale AD password.
if (decision.ErrorCode == "DIRECTORY_SYNCHRONIZATION_FAILED")
{
return Failure("La contraseña institucional fue aceptada, pero no se pudo preparar la cuenta en Active Directory. Intenta nuevamente o contacta a soporte.");
}
// Only a genuine broker/SGO outage permits the documented cached
// domain-credential path for an existing account.
return DomainCredential(
domain,
userName,
securePassword,
decision.Kind == BrokerDecisionKind.Unavailable
? "El servicio institucional no está disponible; Windows validará la contraseña guardada en el dominio."
: null);
"El servicio de autenticación no está disponible; Windows validará la última contraseña de dominio registrada.");
}
finally
{
@@ -2,9 +2,15 @@ $repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
$synchronizerPath = Join-Path $repositoryRoot 'src\SGU.AuthBroker\Services\ActiveDirectorySynchronizer.cs'
$deployPath = Join-Path $repositoryRoot 'scripts\Deploy-AuthBroker.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
$deploy = Get-Content -LiteralPath $deployPath -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' {
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 '(?s)-ValueName \$disableChangePasswordValueName.*-Type DWord.*-Value 1'
}
It 'scopes exact SGO 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);
Assert.Equal(BrokerDecisionKind.InvalidCredentials, decision.Kind);
Assert.Equal("INVALID_INSTITUTIONAL_CREDENTIALS", decision.ErrorCode);
}
[Fact]
@@ -61,6 +62,23 @@ public sealed class BrokerClientTests
TestContext.Current.CancellationToken);
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",
"SGOAccepted",
TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind);
Assert.Equal("DIRECTORY_SYNCHRONIZATION_FAILED", decision.ErrorCode);
}
private static ProviderSettings CreateSettings() => new()