diff --git a/docs/architecture.md b/docs/architecture.md index 71ad9fa..8e15eb8 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -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 diff --git a/docs/release-0.6.19.md b/docs/release-0.6.19.md new file mode 100644 index 0000000..cd1decb --- /dev/null +++ b/docs/release-0.6.19.md @@ -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. diff --git a/docs/security.md b/docs/security.md index 2845d34..40ce48b 100644 --- a/docs/security.md +++ b/docs/security.md @@ -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 diff --git a/scripts/Initialize-SguDomainController.ps1 b/scripts/Initialize-SguDomainController.ps1 index 5087bd6..66cb3ea 100644 --- a/scripts/Initialize-SguDomainController.ps1 +++ b/scripts/Initialize-SguDomainController.ps1 @@ -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 ` diff --git a/scripts/Install-SguCredentialProviderUpdatePolicy.ps1 b/scripts/Install-SguCredentialProviderUpdatePolicy.ps1 index 97bbf81..c1fe83e 100644 --- a/scripts/Install-SguCredentialProviderUpdatePolicy.ps1 +++ b/scripts/Install-SguCredentialProviderUpdatePolicy.ps1 @@ -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', diff --git a/scripts/New-SguBootstrapPackages.ps1 b/scripts/New-SguBootstrapPackages.ps1 index 49ba07b..3a4e3d6 100644 --- a/scripts/New-SguBootstrapPackages.ps1 +++ b/scripts/New-SguBootstrapPackages.ps1 @@ -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', diff --git a/scripts/Set-SguInstitutionalPasswordPolicy.ps1 b/scripts/Set-SguInstitutionalPasswordPolicy.ps1 new file mode 100644 index 0000000..dabc130 --- /dev/null +++ b/scripts/Set-SguInstitutionalPasswordPolicy.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) +} diff --git a/src/SGU.CredentialProvider/BrokerClient.cs b/src/SGU.CredentialProvider/BrokerClient.cs index d679d20..4cb89a7 100644 --- a/src/SGU.CredentialProvider/BrokerClient.cs +++ b/src/SGU.CredentialProvider/BrokerClient.cs @@ -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(response, timeout.Token).ConfigureAwait(false); + return BrokerDecision.Unavailable(unavailable?.Code ?? $"BROKER_HTTP_{(int)response.StatusCode}"); } catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested) { diff --git a/src/SGU.CredentialProvider/SguCredentialTile.cs b/src/SGU.CredentialProvider/SguCredentialTile.cs index 949185e..4150600 100644 --- a/src/SGU.CredentialProvider/SguCredentialTile.cs +++ b/src/SGU.CredentialProvider/SguCredentialTile.cs @@ -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 { diff --git a/tests/AuthBrokerPasswordAuthority.Tests.ps1 b/tests/AuthBrokerPasswordAuthority.Tests.ps1 index 4d2eedb..dbfac79 100644 --- a/tests/AuthBrokerPasswordAuthority.Tests.ps1 +++ b/tests/AuthBrokerPasswordAuthority.Tests.ps1 @@ -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'" + } } diff --git a/tests/SGU.CredentialProvider.Tests/BrokerClientTests.cs b/tests/SGU.CredentialProvider.Tests/BrokerClientTests.cs index 48dc064..a0d5fc0 100644 --- a/tests/SGU.CredentialProvider.Tests/BrokerClientTests.cs +++ b/tests/SGU.CredentialProvider.Tests/BrokerClientTests.cs @@ -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()