Compare commits

...
23 Commits
Author SHA1 Message Date
alexrg bfa520dec8 Keep CED workstation Wi-Fi available before sign-in and package release 0.6.22 2026-10-14 15:48:44 -06:00
alexrg 2cca02db35 Preserve DNS name lookup across CED and Sala Wi-Fi profiles 2026-10-01 16:48:15 -06:00
alexrg b9756ad3b2 Resolve SGU-DC02 and SI short names from Sala Inmersiva 2026-10-01 16:31:40 -06:00
alexrg 0dd4c4d629 Document SI-03 DNS registration and validation 2026-10-01 15:53:55 -06:00
alexrg 046a815962 Resolve Sala Inmersiva workgroup names from CED 2026-10-01 15:48:04 -06:00
alexrg 2c90802930 Document SI-04 workgroup RDP validation from CED 2026-10-01 15:34:35 -06:00
alexrg 422071ca6a Allow CED and Sala Inmersiva management traffic 2026-10-01 15:10:35 -06:00
alexrg 11d49dc245 Fix CED ConfigMgr notification connectivity and verify online status 2026-10-01 10:30:18 -06:00
alexrg 46c0be732a Configure CED Wi-Fi policy and scoped management enrollment 2026-10-01 10:16:24 -06:00
alexrg b07dbe17d0 Enable workstation remote management through native domain policies 2026-09-30 10:39:52 -06:00
alexrg 414a08ece6 Disable reversible password storage for SGU accounts 2026-09-29 12:00:36 -06:00
alexrg 80baae1b54 Limit reversible password storage to SGU accounts 2026-09-29 11:35:27 -06:00
alexrg 843a1956d6 Honor exact SGO passwords for managed domain users 2026-09-24 13:22:12 -06:00
alexrg 738df9ceea Grant domain Builtin administrators local rights on lab workstations 2026-09-23 16:07:30 -06:00
alexrg 77091c023d Enrich AD thumbnailPhoto from SGU profile images 2026-09-23 11:08:36 -06:00
alexrg 21890047e2 Fix credential provider startup policy command generation 2026-09-23 09:11:29 -06:00
alexrg db35d86df1 Manage workstation RDP and WinRM through client GPO 2026-09-23 08:36:16 -06:00
alexrg 63fbaf65dc Target verified v0.6.16 client release in startup policy 2026-09-22 16:44:47 -06:00
alexrg 6fb703b015 Run verified client update under Windows startup policy 2026-09-22 16:38:47 -06:00
alexrg acfdcd5bbf Fix institutional sign-in rollout and default selection 2026-09-22 16:29:09 -06:00
alexrg 771dc60f7d Unify AD and SGU sign-in in Acceso Institucional 2026-09-22 16:00:16 -06:00
alexrg 2e972a06bd Deploy credential provider updates at startup 2026-09-22 15:23:50 -06:00
alexrg 42f405e69c Unify La Salle sign-in experience 2026-09-22 15:03:12 -06:00
65 changed files with 3630 additions and 94 deletions

No files matched your search

+18 -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
@@ -53,6 +60,7 @@ visible while the browser populates those controls asynchronously.
Operational documentation: Operational documentation:
- [Centro de Experiencia Digital Wi-Fi policy and management](docs/ced-network-operations.md)
- [One-command server recovery and client enrollment](docs/bootstrap-recovery.md) - [One-command server recovery and client enrollment](docs/bootstrap-recovery.md)
- [Broker location, health, timeout, and recovery](docs/broker-operations.md) - [Broker location, health, timeout, and recovery](docs/broker-operations.md)
- [Windows domain join and remote-access onboarding](docs/windows-client-onboarding.md) - [Windows domain join and remote-access onboarding](docs/windows-client-onboarding.md)
+31 -9
View File
@@ -52,15 +52,36 @@ 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 explicitly rejects the credential, the provider stops without trying AD.
If SGU accepts it but AD synchronization fails, the provider reports that
failure without trying a stale AD verifier. Only a genuine broker/SGU outage
uses the documented Windows cached-domain-credential fallback, for an existing
account. A matching username pattern alone never provisions an account.
The domain bootstrap creates a fine-grained password policy for the three SGU
role security groups. It allows the broker to record the exact password SGU
accepted even when the normal domain complexity policy would reject it, while
keeping reversible password storage disabled. The domain default remains
unchanged. Bootstrap clears the per-user reversible-storage flag for members of
the three SGU groups, and the broker clears it before every password
synchronization. Existing reversibly stored passwords remain so until the next
password reset; successful Acceso SGU sign-in synchronizes the password using
the disabled setting.
Before an account becomes usable, the broker applies explicit deny ACEs for the Before an account becomes usable, the broker applies explicit deny ACEs for the
Active Directory `Change Password` extended right to SELF and Everyone. Users Active Directory `Change Password` extended right to SELF and Everyone. Users
@@ -125,9 +146,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
+7
View File
@@ -56,6 +56,13 @@ Eso es comportamiento esperado, no una caída del servicio.
nombre y ubicación. El Credential Provider mantiene su propio límite de **90 nombre y ubicación. El Credential Provider mantiene su propio límite de **90
segundos**: si SGU excede ese presupuesto, Windows continúa por el fallback segundos**: si SGU excede ese presupuesto, Windows continúa por el fallback
normal de AD o credenciales de dominio en caché. normal de AD o credenciales de dominio en caché.
Cuando el HTML confirma la clave institucional, el broker solicita la foto
del endpoint de SGU con la misma sesión autenticada: `tp=1` para alumnos y
`tp=2` para administrativos/docentes. Solo acepta JPEG de hasta 100 KiB, con
un límite adicional de 3 segundos. Un error, HTML de login, timeout o foto
inválida conserva la foto anterior y no impide el inicio de sesión. La
escritura de `thumbnailPhoto` en AD también es independiente de los demás
metadatos y de la sincronización de contraseña.
- El instalador configura recuperación del servicio con reinicios a los 5, 15 - El instalador configura recuperación del servicio con reinicios a los 5, 15
y 60 segundos y reinicia el contador de fallos después de 24 horas. y 60 segundos y reinicia el contador de fallos después de 24 horas.
- Si el broker o SGU no está disponible, el Credential Provider entrega la - Si el broker o SGU no está disponible, el Credential Provider entrega la
+423
View File
@@ -0,0 +1,423 @@
# Centro de Experiencia Digital network
The managed Wi-Fi network is **Centro de Experiencia Digital**, on the ASUS
GT-AX11000 Pro. It replaces Aula Flexible and Sala de Desarrollo for the CED PCs.
Configuration is scoped to:
```text
OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx
```
The current Wi-Fi policy targets member workstations with names beginning
`AF-`, `SD-`, or `SI-` in this OU: 47 enabled domain computers on October 14,
2026. Its WMI filter excludes servers and `APPS-` Ethernet workstations.
LCI-77 uses a local profile and remains outside the domain.
## Router configuration
| Network | Result |
| --- | --- |
| Centro de Experiencia Digital | VLAN 53, 192.168.54.0/24, gateway 192.168.54.1, WPA2/WPA3-Personal, AES, 2.4/5 GHz |
| Sala de Desarrollo | Disabled, configuration retained for recovery |
| Sala Inmersiva | Existing SSID, key, VLAN 54 and 192.168.55.0/24 retained |
| Invitados CED | Retained |
| Esports CED | Retained with its pre-existing enable/disable state |
| NewMatrix | Existing main network retained |
The previous Aula Flexible shared key is retained privately. The old 20 Mbps
download / 5 Mbps upload cap is removed from the CED network. DHCP provides the
domain DNS server at 192.168.54.211. AP isolation is off for management between
the CED PCs. Existing separation of the other guest networks is retained.
Router configuration changes restart shared radios and can interrupt all Wi-Fi
connections briefly, including unchanged SSIDs. SGU-DC02 itself is connected by
Wi-Fi, despite LCI-77 having Ethernet. Prepare a server reconnection task before
applying router changes. Radio/DFS readiness can take several minutes; do not
repeat Apply while waiting for recovery.
## Group Policy and future computers
`Set-SguCedWifiPolicy.ps1` publishes a native computer WLAN policy in
**CED - Wi-Fi de salas**. The GPO is enforced on the CED OU, disables user
settings, and filters for AF, SD, and SI member workstations. The native
**Centro de Experiencia Digital** profile remains a read-only Group Policy
profile. An additional **CED - Equipo** all-user profile caches the same network
credentials in Windows' protected machine profile store. This cache is available
before any user signs in and survives sign-out.
The Personal shared key is stored in the native AD WLAN policy object. Its ACL
permits the CED computer reader group and direct CED computer SIDs, plus the
administrative/system identities needed to maintain it. The key is not stored
in SYSVOL scripts or in this repository. Exported profiles containing the key
must remain in an administrator-only private directory.
On some Windows clients the native CSE left the Personal key unprotected;
others did not have the CED profile at all. `Repair-SguCedWifi.ps1` uses the
documented Native Wi-Fi API to repair local key protection and prepare the cached
all-user profile. Initial provisioning can read the existing restricted AD WLAN
object using the computer account; no administrator password is stored on the
client. The cached profile subsequently works without an AD connection.
The helper combines native interface state with WLAN service events when Windows
denies querying the current SSID. It does not change location privacy consent.
The computer startup policy installs **CED WiFi policy connection**, a SYSTEM
task triggered by boot, computer policy completion, sign-out, and successful
Wi-Fi connection events. It replaces the previous 15-minute reconnection loop.
WLAN AutoConfig performs normal automatic connections. The repair helper exits
after reconciling the cached profile; there is no client polling interval.
Its code directory permits writes only by SYSTEM and local administrators.
**CED WiFi OU readers refresh** on SGU-DC02 still updates the reader group and
direct policy ACLs every 15 minutes, restricted to AF, SD, and SI computers.
New domain computers in the OU receive policy automatically after reader refresh
and normal Group Policy processing. They still need an initial path to a domain
controller, such as Ethernet or an existing Wi-Fi profile, to join the domain
and receive their first policy. Existing disconnected computers likewise need
one initial connection to fetch the correction. The cached Personal profile
does not require user credentials, RADIUS, or a certificate authority. Domain
DNS and management services still depend on their servers being available.
CED profiles use automatic connection with automatic switching disabled.
Other saved all-user Wi-Fi profiles are retained and changed to manual
connection. The sign-in network selector stays available and the policy allows
creating an all-user emergency profile. A manually selected alternate connection
is preserved by routine repair; explicit `-PreferCedNow` requests migration and
attempts to restore the previous profile if CED does not connect. Emergency
connectivity does not itself provide a route to the domain controller.
`Set-SguCedDnsPolicy.ps1` creates **CED - DNS de dominio**, linked only to the
same OU. Its NRPT rule directs the internal domain namespace to 192.168.54.211.
This avoids public Ethernet DNS competing with Wi-Fi domain DNS on multihomed
PCs. Public namespaces retain their normal resolution settings.
On CED, the managed Wi-Fi adapter uses 192.168.54.211 and 192.168.54.1 as its
resolvers. On a manually chosen alternate Wi-Fi, the helper restores DHCP DNS
instead of leaving CED's resolver addresses pinned. Internal names continue
to use the NRPT domain rule; public fallback does not provide domain services.
The seven pre-existing SI DNS records originally created for workgroup hosts
also permit their respective domain computer accounts to update their own
records securely after a subnet change. Secure-only zone updates are preserved.
## Windows Admin Center
`Set-SguCedWacCertificate.ps1` provisions a non-exportable RSA 3072-bit server
certificate for `sgu-dc02.lci.lasalle.mx` and `sgu-dc02`, binds it to the WAC
frontend, and distributes its public trust through **CED - Confianza de
administracion** in the CED OU. It backs up the previous WAC settings before
changing the binding. It does not install a certificate authority.
LCI-77 trusts the public certificate in the current user's Root store. This does
not join it to the domain. Keep the WAC private key on SGU-DC02. Renew the
certificate and update the trust policy before expiry.
`Sync-SguWacDomainConnections.ps1 -ComputerOuDn <CED OU>` limits inventory additions
to this OU. Verification queries actual OS instances through WAC; having a saved
connection alone is not proof of management connectivity. Existing unrelated WAC
inventory entries are not deleted. Authentication and certificate validation
remain enabled.
## Configuration Manager
The existing collection **LCI00014** is named **Centro de Experiencia Digital**.
Its query uses the exact CED canonical OU. Periodic and incremental evaluation
are enabled, preserving the collection ID and existing client-setting deployments.
AD system discovery remains enabled, including its existing incremental polling.
`Set-SguCedConfigMgrCollection.ps1` reproduces this configuration.
`Set-SguCedClientSource.ps1` prepares the complete Microsoft-signed client media
in `C:\ProgramData\LCI-Admin\ClientSource`, shared as `CEDClient$` with encrypted
SMB. CED computers have read access, including direct computer permissions for
machines whose existing Kerberos tickets predate reader-group membership. The
administrative `SMS_LCI` share is not opened to client computers.
Use `/source` alone for this source, plus the installation properties
`SMSSITECODE=LCI SMSMP=sgu-dc02.lci.lasalle.mx`. Adding `/mp` gives management-point
and distribution-point discovery priority and previously left these installs
waiting. The native startup policy also installs a SYSTEM enrollment task for
future CED computers. It validates current OU membership and the Microsoft
signature, skips an existing client or running setup, and retries every 30 minutes.
For an existing computer migration, prepare DNS/policy and migrate Wi-Fi first.
Verify the new connection before starting the client installer. Changing Wi-Fi
during source download can fail the installation and require a retry.
```powershell
# Run on SGU-DC02 with authorized administrative credentials supplied in memory.
.\scripts\Set-SguCedClientSource.ps1
.\scripts\Set-SguCedWifiPolicy.ps1 -ProfilePath <private clear-key WLAN XML>
.\scripts\Sync-SguCedWifiReaders.ps1 -InstallRefreshTask
.\scripts\Set-SguCedDnsPolicy.ps1
.\scripts\Set-SguCedWacCertificate.ps1
.\scripts\Set-SguCedConfigMgrCollection.ps1
.\scripts\Set-SguCedNotificationFirewall.ps1
$credential = Get-Credential
.\scripts\Invoke-SguCedPreparation.ps1 -InventoryPath <private inventory JSON> -Credential $credential -MigrateWifi
.\scripts\Test-SguCedManagedNodes.ps1 -Credential $credential
.\scripts\Invoke-SguCedPreparation.ps1 -InventoryPath <private inventory JSON> -Credential $credential -InstallClient
```
Inventory JSON is an array of `Name`, `IP`, and `WinRM` properties. Preparation
validates the AD scope and actual remote hostname, domain, and secure channel
before changing anything. It prefers current DNS over a stale DHCP inventory
address. Existing DNS settings are backed up on each client.
## Rollout validation — October 1, 2026
After the final router radio restart, the live client validation returned:
| Check | Result |
| --- | --- |
| CED computers in scope | 39 |
| Reachable over authenticated WinRM | 39 |
| Live CED SSID and matching successful policy profile event | 39 |
| CcmExec running and site LCI assigned | 39 |
| WAC public certificate trusted in the machine Root store | 39 |
| WAC returned actual OS instances over validated HTTPS | 39 |
ConfigMgr also reported 39 CED resources with `Client=1` and the expected OU
attribute. SD-06 was initially unavailable; it was prepared, migrated, installed,
and validated after being made available. The client installer logs on SD-06,
SD-09, and the SD-27 pilot returned exit code 0. LCI-77 successfully reconnected
with its local profile while remaining outside the domain. The router UI showed
the new SSID with WPA2/WPA3-Personal and Sala de Desarrollo disabled.
Private per-machine validation JSON and the router screenshot are stored outside
Git in the administrator's private CED network directory. No passwords, shared
keys, private certificates, or original clear-key WLAN exports are committed.
## Verification and recovery
`Test-SguCedManagedNodes.ps1` checks live SSID, the successful profile event,
reachable WinRM, CcmExec, assigned site, and WAC root trust. Also verify the WAC
OS endpoint, ConfigMgr server-side client registration, and collection membership.
The validation script also reads `CNIsOnline` from the local site provider and
returns it as `NotificationOnline`. A null value means provider data is unavailable;
it must not be interpreted as an offline client.
An installation wizard success screen or a scheduled installation request does
not establish that installation completed.
### Configuration Manager gray X icons
The green check and gray X indicate the client notification connection. They are
separate from `Client=Yes`, recent client activity, and client health. On October 1,
AF-02 through AF-06 and AF-10 remained reachable with CcmExec running, but their
notification logs repeatedly reported `Failed to find a access point ... 8000000a`.
Restarting CcmExec restored management-point discovery. The server was listening
on TCP 10123, but connections timed out until the missing inbound firewall rule
was added. `Set-SguCedNotificationFirewall.ps1` reproduces that rule for only
SGU-DC02's CED address, the Domain firewall profile, and the notification host
process. It initially allowed source subnet `192.168.54.0/24`; it now also allows
`192.168.55.0/24` for the requested Sala Inmersiva management access described below.
After correcting the port, restart CcmExec only on affected clients when needed,
then check their notification keep-alive logs and server-side `CNIsOnline`.
Allow time for status reports and refresh the console. Do not reinstall the
client solely because its notification icon is gray.
The follow-up validation reported all 39 CED devices reachable and
`NotificationOnline=True`, including all six affected AF clients. The server log
confirmed 39 online notification sessions (6 TCP and 33 HTTP). No operating-system
restart or client reinstallation was needed.
### CED and Sala Inmersiva inter-network access
At the administrator's subsequent request on October 1, the router's Guest
Network Pro **Access Intranet** settings were changed to allow the CED (VLAN 53,
`192.168.54.0/24`) and Sala Inmersiva (VLAN 54, `192.168.55.0/24`) networks to
communicate. From the CED profile, only Sala Inmersiva was newly selected. After
applying and reloading the router, the Sala Inmersiva profile also showed CED
selected: the setting is reciprocal. Its pre-existing Main Network selection was
preserved. Esports CED and Invitados CED were not selected for this new connection.
No SSID, password, subnet, or Wi-Fi GPO scope was changed. Applying the router
configuration briefly restarted wireless connections; LCI-77 reconnected using
its existing CED profile.
Authenticated WinRM from SGU-DC02 reached SD-17 (`192.168.55.19`) and SD-21
(`192.168.55.20`), with both reporting live SSID **Sala Inmersiva**. Both clients
could reach the management point's HTTP endpoint and, after extending the scoped
notification firewall rule, TCP 10123. A separate client-to-client test confirmed
TCP 2701 from AF-02 on CED to SD-17 on Sala Inmersiva and in the reverse direction.
AF-02 could also reach SD-17's WinRM port. These are service reachability checks,
not proof that every Windows service accepts connections from every peer.
Use DNS names or IP addresses in management tools across these subnets. Router
routing alone does not make every computer appear automatically in Windows
Explorer's Network view. Windows firewall rules, authentication, and enabled
management services still apply. New Windows clients still need discovery and
client enrollment; Wi-Fi profile deployment remains limited to the CED OU.
#### Workgroup RDP validation: SI-04
The initial AF/SD management tests did not establish short-name resolution for
workgroup computers in Sala Inmersiva. SI-04 was subsequently checked before
domain enrollment. It had no AD computer object or domain DNS record, and the
router answered its short name only when explicitly queried at `192.168.55.1`.
On October 1 its DHCP address was `192.168.55.138`.
From LCI-77 with live SSID **Centro de Experiencia Digital**, TCP 3389 to that
address succeeded. An actual RDP connection negotiation returned a 19-byte reply
with negotiation response type 2 and selected protocol 2 (HYBRID/NLA). This
validates the RDP endpoint across the VLANs, not an authenticated desktop session.
This initial test did not enroll SI-04 or create a domain DNS record. Before
enrollment, an authenticated RDP login still requires an authorized local SI-04
account.
#### Workgroup names available from CED
The subsequent DNS repair publishes A records in the existing secure AD DNS
zone `lci.lasalle.mx`, without creating AD computer objects. The router's Sala
Inmersiva client list identified six additional Windows workgroup names:
`SI-02`, `SI-04`, `SI-05`, `SI-06`, `SI-07`, and `SI-08`. Each address was verified
with a direct DNS query to `192.168.55.1` before publication. SI-04 currently
resolves to `192.168.55.138`.
SI-03 was subsequently added after a direct router DNS query returned
`192.168.55.120`. Its A record and manifest entry bring the approved list to
seven computers, SI-02 through SI-08. The Windows application resolver on LCI-77
successfully resolved **SI-03** while connected to CED. SI-01 did not have a router
DNS answer during this follow-up and was not assigned a guessed address.
On SGU-DC02, task **LCI - Sala Inmersiva workgroup DNS** runs
`scripts/Sync-SguSalaWorkgroupDns.ps1` as SYSTEM every five minutes, using the
protected folder `C:\ProgramData\LCI-Admin\Sala-DNS`. No credentials are stored.
Its `manifest.json` contains the approved names and their last published
addresses. Only router answers in `192.168.55.0/24` are accepted. The sync refuses
to overwrite records changed by another administrator and stops managing a name
once it has an AD computer object. New names require explicit approval and an
entry in this manifest; arbitrary guest/IoT clients are not imported.
Records have a five-minute TTL. A failed router query preserves the last record
and reports an error in `last-result.json` and the task result; the TTL does not
expire the server record. Review these errors if an address becomes stale.
The first two SYSTEM runs completed successfully with all six records current.
The zone continues to allow secure dynamic updates only.
Domain clients use their domain suffix and existing **CED - DNS de dominio** GPO.
The workgroup administrator PC LCI-77 additionally needed the Wi-Fi connection
suffix `lci.lasalle.mx` and an NRPT rule for that namespace pointing to
`192.168.54.211`; `scripts/Set-SguCedAdminDns.ps1` reproduces this local setup.
The prior suffix is saved in `LCI77-Sala-DNS-before.json` in the protected private
folder. The rule applies only to this DNS namespace; existing Tailscale rules
remain intact. A later SSID switch showed that Windows cleared the connection
suffix on Sala Inmersiva, so an adapter suffix alone was insufficient. The script
now sets a persistent global DNS search list with `lci.lasalle.mx` first and
preserves existing global and interface suffixes, including Tailscale's suffix.
The original global list is saved separately in `LCI77-DnsSearchList-before.json`.
Validation used Windows' application resolver (`System.Net.Dns.GetHostAddresses`),
not just an explicit DNS-server query. All six short names resolved on LCI-77
while its live SSID was **Centro de Experiencia Digital**. AF-02, at
`192.168.54.130`, also resolved SI-04 correctly. A TCP connection opened using
the name **SI-04** from LCI-77 reached port 3389 and received a successful RDP
HYBRID/NLA negotiation response. This verifies name resolution and the RDP
endpoint across networks; it does not assert an authenticated desktop session.
To undo this DNS repair, disable the sync task first. Remove only manifest-owned
A records that still match their last published IP and have no AD computer object.
On LCI-77, restore the saved global search list and Wi-Fi suffix, and remove only
the NRPT rule with the
comment `CED domain DNS for local administrator Wi-Fi`. Keep the domain GPO and
unrelated DNS rules. These DNS changes require no router apply or radio restart.
#### Sala Inmersiva to SGU-DC02 name resolution
The reverse direction needed an additional change: Sala's original router DNS
at `192.168.55.1` returned NXDOMAIN for both `SGU-DC02` and its FQDN. Guest Network
Pro now assigns **192.168.54.211** as Sala Inmersiva's DHCP DNS server. This change
keeps its SSID, authentication, VLAN 54, and gateway `192.168.55.1`. Applying it
briefly restarted the radios; a temporary reconnection task protected SGU-DC02
and was removed after verifying server access. CED, Invitados CED, and Esports CED
were visible again after a fresh wireless scan. LCI-77 returned to CED after testing.
Workgroup clients with no domain suffix also need an answer to the bare server
name. `scripts/Set-SguCedShortNameDns.ps1` creates the narrowly scoped AD-integrated
DNS zone `sgu-dc02`, with an apex A record for `192.168.54.211` and dynamic updates
disabled. The regular `sgu-dc02.lci.lasalle.mx` record is unchanged. No root zone,
domain membership, hosts-file entry, or WINS service is created.
To preserve bare SI names for clients receiving the new DNS setting,
`scripts/Sync-SguSalaShortNames.ps1` similarly maintains the seven approved SI
labels. The existing five-minute Sala DNS task invokes this helper after updating
the regular domain records. The helper mirrors each FQDN A record into its
corresponding bare-name zone and refuses to overwrite records that differ from
its protected `short-names-owned.json`. It logs to `short-names-result.json`.
All eight bare-name answers were verified, and the SYSTEM task returned exit 0.
GlobalNames support remains disabled as before this change.
LCI-77 temporarily connected to live SSID **Sala Inmersiva**, received
`192.168.55.201` with DNS `192.168.54.211`, and successfully queried the bare
`SGU-DC02`, its FQDN, SI-03's FQDN, and a public Internet name. This verifies the
new DHCP setting and DNS access across the VLANs. SI-03 itself was not remotely
reconfigured: its WinRM ports were unavailable, so its user was asked to reconnect
Wi-Fi and verify the short name. Existing clients may keep their previous DHCP
DNS settings until reconnection or lease renewal.
#### Windows application resolution on workgroup clients
On October 1, LCI-77 resolved SI-04 again after returning to CED, but lost Windows
application resolution on Sala when its connection suffix disappeared. After the
persistent search-list repair, `System.Net.Dns.GetHostAddresses` resolved SI-04
and SGU-DC02 on both SSIDs. A TCP socket explicitly bound to LCI-77's Sala address
`192.168.55.201` connected by the short name `SGU-DC02` to `192.168.54.211:3389`
and received a 19-byte successful HYBRID/NLA negotiation response. This confirms
the RDP endpoint is reachable across VLANs; no authenticated desktop session
was tested. LCI-77 was returned to CED after validation.
A user screenshot from **SI-04** shows RDP error `0x104` before credentials:
the bare name SGU-DC02 is not found. A default `Resolve-DnsName` also reports
`ERROR_INVALID_NAME`, while `Resolve-DnsName -Type A -DnsOnly` returns the correct
server IP. DNS-server answers alone do not verify the Windows application
resolver. The user applied this elevated client repair on SI-04 and returned
successful application-resolution and RDP TCP checks:
```powershell
$s = @('lci.lasalle.mx') + @((Get-DnsClientGlobalSetting).SuffixSearchList) + @(Get-DnsClient | Select-Object -ExpandProperty ConnectionSpecificSuffix)
Set-DnsClientGlobalSetting -SuffixSearchList @($s | Where-Object { $_ } | Select-Object -Unique)
Clear-DnsClientCache
[System.Net.Dns]::GetHostAddresses('SGU-DC02')
Test-NetConnection SGU-DC02 -Port 3389
```
SI-04's application resolver returned `192.168.54.211`. `Test-NetConnection`
returned `TcpTestSucceeded: True` using Wi-Fi 2, source `192.168.55.138`, target
`SGU-DC02`, and port 3389. This confirms the client DNS repair and connectivity;
an authenticated desktop session has not been confirmed. The suffix change is
persistent and does not require adding SI-04 to the domain. The same repair has
not yet been applied to SI-03.
This configures DNS lookup without domain enrollment. For an immediate test,
use `SGU-DC02.lci.lasalle.mx` in Remote Desktop. SI-03's WinRM ports and DCOM
management were unavailable; an authenticated session from that PC remains
unverified. On SGU-DC02, RDP is enabled, TermService is running, TCP 3389 listens,
and the existing RDP firewall rule already allows access. No additional firewall
opening or NLA change was needed.
Internal DNS now depends on SGU-DC02 in Sala as it already does in CED. Personal
Wi-Fi authentication still does not require RADIUS or domain membership. To roll
back this follow-up, restore Sala's DNS selection to **Default**, disable the
short-name helper invocation, and remove only the eight owned bare-name zones
after comparing their A records with `short-names-owned.json`. Keep the existing
secure domain zone and the original approved-name synchronization task.
To recover the previous Wi-Fi, first provision an existing known-good profile
and reconnection task on SGU-DC02 and affected PCs. Then restore Aula Flexible on
VLAN 53, or re-enable the preserved Sala de Desarrollo network, as appropriate.
Disable the CED GPO links and remove the CED maintenance/enrollment tasks when
rolling back the managed configuration. Use each client's `CED-dns-before.json`
to restore DNS. For WAC, restore the saved frontend settings and certificate
binding before removing the public trust policy. Do not remove unrelated GPOs,
profiles, certificates, or guest networks.
The existing Configuration Manager 2103 / Windows Server 2025 support limitation
is not changed by this network repair.
## References
- [Microsoft native WLAN Group Policy protocol](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-gpwl/481e4e64-5e95-4ada-aae8-ec93ed69559a)
- [Native Wi-Fi profile storage and key protection](https://learn.microsoft.com/en-us/windows/win32/api/wlanapi/nf-wlanapi-wlansetprofile)
- [Computer startup script protocol](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-gpscr/ff1fd13e-1e18-4160-9b50-0263e108e5e1)
- [Configuration Manager client source selection](https://learn.microsoft.com/en-us/intune/configmgr/core/servers/deploy/configure/boundary-groups-distribution-points)
- [Domain DNS policy cmdlet](https://learn.microsoft.com/en-us/powershell/module/dnsclient/add-dnsclientnrptrule)
- [Windows DNS suffix search and application resolution](https://learn.microsoft.com/en-us/windows-server/networking/dns/queries-lookups)
- [Configuration Manager client monitoring](https://learn.microsoft.com/en-us/intune/configmgr/core/clients/manage/monitor-clients)
- [Configuration Manager connection ports](https://learn.microsoft.com/en-us/intune/configmgr/core/plan-design/hierarchy/ports)
+50
View File
@@ -0,0 +1,50 @@
# Actualización Wi-Fi para el dominio existente
Este paquete publica la política **CED - Wi-Fi de salas** para las estaciones
`AF-*`, `SD-*` y `SI-*` de Centro de Experiencia Digital, dentro de Laboratorio.
Excluye servidores y estaciones `APPS-*`. Está preparado para el dominio
`lci.lasalle.mx`, el controlador local `192.168.54.211` y el SSID
**Centro de Experiencia Digital**. Para otra infraestructura, revise estas
direcciones y los nombres en los scripts antes de publicar.
En el laboratorio actual la actualización ya está publicada en ambos
controladores. Las estaciones desconectadas necesitan una conexión inicial al
dominio para obtenerla. Una vez conectadas, en PowerShell como administrador:
```powershell
gpupdate.exe /target:computer /force
```
Si Windows solicita reiniciar para ejecutar la instalación de equipo, reinicie.
La política instala un perfil Wi-Fi de todos los usuarios, protegido por Windows,
que funciona antes del inicio de sesión y después de cerrarla. Conserva el
selector de redes para emergencias. Las otras redes guardadas se conectan
manualmente; una conexión alternativa elegida a mano se respeta.
## Publicación administrativa
Ejecute en SGU-DC02 con permisos de administración de dominio y GPO. Mantenga
juntos los seis scripts del paquete. Proporcione un perfil Personal WPA2/WPA3 AES
con su clave en una ubicación privada accesible solamente por administradores.
No lo coloque en SYSVOL, repositorios, notas de release ni carpetas compartidas.
```powershell
.\Set-SguCedWifiPolicy.ps1 -ProfilePath 'C:\ruta-privada\CED.xml' -DomainController SGU-DC02
.\Sync-SguCedWifiReaders.ps1 -DomainController SGU-DC02 -InstallRefreshTask
```
La publicación usa WLAN nativo de Windows y un script de inicio de equipo de
Directiva de grupos. La recuperación adicional se ejecuta como SYSTEM al
arrancar, terminar una actualización de políticas, cerrar sesión o conectar
Wi-Fi; no sondea periódicamente. La clave se lee del objeto WLAN restringido de
AD usando autenticación de equipo con firma y cifrado LDAP; se conserva cifrada
en el almacén de perfiles de Windows. No hay contraseñas de administrador en el
cliente ni claves Wi-Fi en los scripts del paquete.
La GPO existente también conserva su integración previa con Configuration
Manager. Si el dominio usa una versión propia de
`Invoke-SguCedClientEnrollment.ps1`, conserve esa versión al publicar.
El estado sin secretos queda en
`C:\ProgramData\LCI-Admin\CED-WiFi\machine-wifi-status.json`.
Consulte `ced-network-operations.md` para alcance, DNS y recuperación.
+6 -3
View File
@@ -232,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:
+7 -4
View File
@@ -27,13 +27,16 @@ rol, `TraceId`, resultado y tiempo total. Los Event ID estables distinguen:
- `1100` SGU aceptó la autenticación; `1101` timeout; `1102` fallo de red/DNS; - `1100` SGU aceptó la autenticación; `1101` timeout; `1102` fallo de red/DNS;
- `1200` enriquecimiento completado y cantidad de campos; `1201` HTML sin los - `1200` enriquecimiento completado y cantidad de campos; `1201` HTML sin los
IDs admitidos; `1202` timeout; `1203` excepción; `1204` página opcional no IDs admitidos; `1202` timeout; `1203` excepción; `1204` página opcional no
disponible; disponible; `1205` foto SGU no disponible o timeout; `1206` imagen rechazada
por tipo, tamaño o formato;
- `1300` fallo de sincronización AD; `1301` metadatos opcionales no aplicados; - `1300` fallo de sincronización AD; `1301` metadatos opcionales no aplicados;
`1302` membresía RDP opcional no aplicada; `1303` cuenta agregada a su grupo `1302` membresía RDP opcional no aplicada; `1303` cuenta agregada a su grupo
institucional de Alumnos, Administrativos o Docentes. institucional de Alumnos, Administrativos o Docentes; `1304` cambio de
contraseña denegado; `1305` foto opcional no aplicada en AD.
No se almacena HTML, contraseña, hash de contraseña ni contenido de la Los registros no almacenan HTML, contraseñas, hashes ni cuerpos de respuesta
respuesta SGU. de SGU. Solo la imagen JPEG validada se guarda en `thumbnailPhoto` del usuario
de Active Directory; sus bytes no aparecen en los eventos.
## Retención ## Retención
+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.
+19
View File
@@ -0,0 +1,19 @@
# v0.6.19 — SGU password authority
- Add a fine-grained Active Directory password policy scoped to the three
`SGU-*` role groups. A password accepted by SGU is stored unchanged in AD,
including short passwords that the default domain complexity policy rejects.
Other domain accounts keep their existing policy.
- Apply and verify this policy during server bootstrap. Existing SGU accounts
receive it through their role-group membership.
- Stop institutional login immediately when SGU explicitly rejects a password.
When SGU accepts it but AD synchronization fails, show a distinct error
instead of trying an older AD password.
- Preserve the documented cached-domain fallback only while the broker or SGU
is genuinely unavailable.
Operational validation: on the domain controller, disposable users in each of
`SGU-Alumnos`, `SGU-Administrativos`, and `SGU-Docentes` accepted a three-character
password and were removed after the test. The three originally reported
accounts still require a real SGU sign-in to finish AD provisioning; no student
password was requested or stored for testing.
+20
View File
@@ -0,0 +1,20 @@
# v0.6.20 — SGU-scoped reversible password storage
- Enable reversible password storage only for members of the three SGU role
groups (`SGU-Alumnos`, `SGU-Administrativos`, and `SGU-Docentes`). The
domain-wide default password policy remains unchanged.
- Before synchronizing a valid Acceso SGU login, the broker enables the
per-account AD flag and then writes the exact SGU-accepted password. Existing
role-group members are repaired by server bootstrap and the password-policy
deployment script.
- Add structured broker event 1306 when the per-account setting is enabled.
- Document that reversible storage allows a privileged directory-data reader to
recover the original password, and that existing passwords are rewritten only
after their next successful SGU password synchronization.
- Correct references that called the institutional system “SGO”; the product is
SGU.
The setting is intentionally limited to the SGU-managed role groups. Do not
apply it to unrelated domain users. Existing SGU accounts need a successful
Acceso SGU sign-in (or another authorized password reset) before their currently
stored password is rewritten using reversible encryption.
+15
View File
@@ -0,0 +1,15 @@
# v0.6.21 — Disable reversible password storage for SGU accounts
- Set `ReversibleEncryptionEnabled` to false in the fine-grained policy scoped
to `SGU-Alumnos`, `SGU-Administrativos`, and `SGU-Docentes`.
- Clear the per-account reversible-encryption flag for existing members of those
role groups, and make bootstrap keep the flag disabled.
- Update the Auth Broker to clear the flag before synchronizing any password
accepted by SGU, so future and existing managed accounts stay on one-way
password storage.
- Add broker event 1307 for an account whose reversible-storage flag is cleared.
The default domain policy remains unchanged and disabled. Password values that
were already stored reversibly are not transformed by changing these settings;
they are replaced using one-way storage when SGU next resets the password. A
successful Acceso SGU sign-in performs that synchronization.
+54
View File
@@ -0,0 +1,54 @@
# v0.6.22 — Wi-Fi de equipo antes del inicio de sesión
Corrige las estaciones de Centro de Experiencia Digital que perdían Wi-Fi al
cerrar sesión y no podían contactar al dominio para el primer acceso de un
usuario.
- La GPO **CED - Wi-Fi de salas** prepara un perfil de todos los usuarios
**CED - Equipo**, con conexión automática a **Centro de Experiencia Digital**.
Windows protege la clave en su almacén de perfiles de equipo.
- Alcance: estaciones miembro `AF-*`, `SD-*` y `SI-*` bajo la OU Centro de
Experiencia Digital dentro de Laboratorio. Los servidores y `APPS-*`, que usan
Ethernet, quedan excluidos por filtro WMI y comprobación local.
- Conserva el selector de redes en el inicio de sesión. Las demás redes guardadas
se conectan manualmente para emergencias; la recuperación habitual respeta una
conexión alternativa elegida por el usuario y restaura su DNS por DHCP.
- Sustituye la reconexión periódica del cliente por recuperación ante eventos de
arranque, políticas, cierre de sesión y conexión Wi-Fi. Una configuración ya
correcta no reinstala el perfil ni vuelve a registrar la tarea.
- La provisión inicial consulta el controlador local mediante LDAP con firma y
cifrado, usando la cuenta del equipo. Evita intentar acceder a la IP privada
del controlador Azure desde estaciones sin esa ruta.
- Identifica la conexión mediante estado nativo y eventos WLAN cuando Windows
restringe la consulta del SSID, sin cambiar el consentimiento de ubicación.
- La publicación de la GPO es idempotente y mantiene la clave fuera de SYSVOL y
de los archivos del release.
## Paquetes
- **sgu-ced-wifi-policy-0.6.22.zip**: scripts y guía para actualizar la política
Wi-Fi de este dominio existente. No requiere ejecutar el bootstrap del bosque.
- Se mantienen los paquetes de bootstrap Windows, servidor, Linux e
infraestructura Azure. El paquete de servidor incluye también los scripts
necesarios para publicar esta corrección Wi-Fi.
- **SHA256SUMS-0.6.22.txt** permite verificar los cinco ZIP.
La política ya está publicada en los dos controladores del laboratorio. Una
estación desconectada necesita conectividad inicial al dominio para obtenerla;
después puede ejecutar `gpupdate /target:computer /force` y reiniciar si Windows
lo solicita. El perfil de equipo queda disponible sin sesión iniciada.
El paquete específico Wi-Fi está configurado para `lci.lasalle.mx`, el SSID CED y
el controlador local `192.168.54.211`; revise sus parámetros antes de reutilizarlo
en otra infraestructura. El bootstrap de servidor crea un bosque nuevo: para
actualizar el dominio existente use el paquete Wi-Fi y su README.
## Validación
- Compilación Release de Auth Broker y Credential Provider.
- 71 pruebas correctas: 42 del núcleo, 22 del broker y 7 del proveedor.
- Análisis sintáctico de los scripts y compilación del auxiliar nativo en
Windows PowerShell 5.1.
- Verificación SHA-256 de cada archivo de los manifiestos y de los cinco ZIP.
- Segunda publicación idéntica de la GPO sin cambios y archivos de política
coincidentes en SYSVOL de ambos controladores.
+33 -6
View File
@@ -18,6 +18,19 @@ the same source list. RDP uses a separate allowlist. See
`Marshal.ZeroFreeGlobalAllocUnicode`; managed references are released as soon `Marshal.ZeroFreeGlobalAllocUnicode`; managed references are released as soon
as each request completes. as each request completes.
- The broker uses the exact received value for both NTLM and AD `SetPassword`. - The broker uses the exact received value for both NTLM and AD `SetPassword`.
- The `SGU - Institutional password authority` fine-grained AD password policy
applies only to the global security groups `SGU-Alumnos`,
`SGU-Administrativos`, and `SGU-Docentes`. It disables AD complexity,
history, and password age requirements and permits passwords from one
character onward so passwords accepted by SGU can be recorded unchanged by AD.
Reversible storage is disabled in this fine-grained policy and in each SGU
account. The default domain password policy remains unchanged for non-SGU
accounts. Bootstrap repairs existing role-group members, and the broker clears
the per-user reversible-storage flag before every `SetPassword`.
- Disabling reversible storage does not rewrite password data already stored in
reversible form. Those existing values remain until each password is reset;
the broker synchronizes the current SGU password on the next successful
Acceso SGU sign-in, at which point AD stores it without reversible encryption.
- Managed `Usuarios-SGU` accounts deny the SELF and Everyone `Change Password` - Managed `Usuarios-SGU` accounts deny the SELF and Everyone `Change Password`
extended right. Only an administrator or the broker through the separate extended right. Only an administrator or the broker through the separate
`Reset Password` right can replace the AD password. `Reset Password` right can replace the AD password.
@@ -87,13 +100,27 @@ 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 and do not submit a Windows
- timeout, TLS/connectivity error, `429`, or `5xx`: submit the unchanged credential credential. An explicit SGU rejection is authoritative, including when an
to Windows. Windows must still validate it against AD or the cached domain older AD password still exists.
verifier, so this does not grant access without the last synchronized password. - `DIRECTORY_SYNCHRONIZATION_FAILED`: SGU accepted the password but AD did not
record it. Show a specific error and do not attempt Windows logon against a
potentially stale AD verifier.
- timeout, TLS/connectivity error, `429`, or `5xx`: submit the unchanged
credential to Windows only for a genuine broker/SGU outage. Windows must still
validate it against AD or its cached domain verifier, so this does not grant
access without a domain credential. This continuity path can accept a
last-known AD password while SGU is unreachable; decide explicitly whether
that availability trade-off is appropriate for each deployment.
- usernames that do not match the institutional key format go directly to
Windows and are never sent to SGU or provisioned by the broker.
Allowing an SGU-accepted three-character password also allows that short
password at the native AD logon surface. Broker rate limiting does not protect
direct AD authentication; domain network exposure and monitoring therefore
remain essential. The policy cannot make a weak upstream password strong.
Redis is deliberately not used for password continuity. A second persistent Redis is deliberately not used for password continuity. A second persistent
password verifier duplicates attackable credential material, while a reversible password verifier duplicates attackable credential material, while a reversible
+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
+33
View File
@@ -0,0 +1,33 @@
# Administradores de las estaciones Windows
El grupo `LCI\Administrators` ubicado en `CN=Builtin` administra Active
Directory y los controladores de dominio. No convierte por sí solo a sus
miembros en administradores locales de las estaciones Windows. `Domain Admins`
sí suele estar en el grupo local `Administrators` de cada equipo unido al
dominio, pero agregar una cuenta a `Domain Admins` le daría mucho más alcance.
La GPO **SGU - Windows client experience**, vinculada a `OU=Laboratorio`,
ejecuta `Enable-SguWorkstationAdministrators.ps1` al inicio de cada equipo
Windows. El script consulta por LDAP a los usuarios (incluidos miembros
anidados) de `CN=Administrators,CN=Builtin,DC=lci,DC=lasalle,DC=mx` y agrega
sus SID de dominio al grupo `Administrators` local. No se aplica a los
controladores de dominio ni a los equipos Linux. Si el DC no responde, no
cambia la pertenencia local y lo reintenta en el siguiente arranque.
En siguientes arranques elimina solo los SID que esta política había agregado
y que ya no pertenecen al grupo de AD. Conserva los administradores locales
y los grupos agregados por otras políticas. Los cambios de membresía de AD
requieren reiniciar la estación y volver a iniciar sesión para obtener un
token de acceso nuevo; no se elevan las sesiones ya abiertas.
Comprobación en un cliente Windows, desde una consola elevada:
```powershell
gpresult /scope computer /r
Get-LocalGroupMember -SID 'S-1-5-32-544'
whoami /groups
```
Para actualizar la política en un equipo encendido, ejecute
`gpupdate /target:computer /force`, reinicie e inicie sesión nuevamente. La
concesión se limita a los equipos Windows que heredan la GPO del laboratorio.
+105
View File
@@ -0,0 +1,105 @@
# Acceso remoto administrado por el dominio
`Install-SguDomainRemoteManagementPolicy.ps1` crea **La Salle - Workstation
remote management**, vinculada y exigida en la raíz del dominio. Su filtro WMI
`ProductType = 1` incluye estaciones Windows 10/11, incluso las nuevas cuentas
en `CN=Computers`, y excluye servidores y controladores de dominio. Solo tiene
configuración de equipo. El bootstrap del controlador instala esta política.
La política usa extensiones nativas de Group Policy:
- Plantillas administrativas: RDP permitido con NLA, listener WinRM y consola remota.
- Preferencias de servicios: `WinRM` y `TermService` automáticos, iniciados cuando
sea necesario; `RemoteRegistry` manual. No reinicia servicios que ya funcionan.
- Preferencias de registro: activa RDP también en la configuración local que
muestra Configuración de Windows.
- Firewall de dominio: 12 reglas para RDP TCP/UDP, WinRM, WMI, RPC, eventos,
servicios, tareas, firewall, volúmenes, rendimiento y SMB administrativo.
Los puertos RPC dinámicos se limitan al servicio correspondiente.
Por defecto, las reglas solo permiten conexiones desde `LocalSubnet`.
`-ManagementAddresses` permite especificar otras redes administrativas que
ya tengan rutas hacia las estaciones. El instalador compara valores, reglas,
archivos y vínculos; una segunda ejecución sin diferencias no modifica la GPO.
```powershell
# En PowerShell elevado del controlador de dominio:
.\scripts\Install-SguDomainRemoteManagementPolicy.ps1 -DomainController SGU-DC02
# Configuración del despliegue actual de Aula Flexible:
.\scripts\Install-SguDomainRemoteManagementPolicy.ps1 -DomainController SGU-DC02 `
-LocalDnsServer 192.168.54.211 -FallbackDnsServer 20.9.81.130 `
-ManagementAddresses @('LocalSubnet','192.168.54.211')
```
Un script de **inicio de equipo de la propia GPO** prepara el endpoint de
Windows PowerShell si está ausente o deshabilitado y comprueba el grupo RDP
institucional. No crea tareas periódicas en las estaciones. La política
preexistente **SGU - Windows client experience** conserva sus scripts de inicio
para Laboratorio y la asignación de administradores; véase
[Administradores de las estaciones Windows](workstation-administrators.md).
Si se proporciona DNS local, el script de inicio solo modifica una interfaz
cuyo segmento conectado contiene ese servidor, después de comprobar que
responde autoritativamente para el dominio. Puede usar otro DNS de AD como
alternativa y solicita el registro DNS del equipo. Conserva las interfaces
de otras redes.
Para aplicar la política a un cliente, ejecute PowerShell como administrador:
```powershell
gpupdate /target:computer /force
gpresult /scope computer /r
Test-ComputerSecureChannel -Verbose
Get-Service WinRM,TermService | Select-Object Name,Status,StartType
Get-NetFirewallRule -PolicyStore ActiveStore -Name 'LaSalle-Management-*' |
Select-Object Name,Enabled,PolicyStoreSourceType
```
La GPO debe figurar aplicada, el canal seguro devolver `True`, ambos servicios
estar activos y las 12 reglas habilitadas con origen `GroupPolicy`.
`gpupdate` aplica registro, servicios y firewall sin cerrar la sesión. Reiniciar
una vez ejecuta además la preparación inicial del endpoint y DNS. La actualización
del proveedor de credenciales es otra GPO de inicio y necesita su propio reinicio.
Para revisar varias estaciones desde SGU-DC02, con una cuenta de administración
del dominio:
```powershell
.\scripts\Get-SguWorkstationRemoteManagementStatus.ps1 -ComputerName `
AF-02.lci.lasalle.mx,AF-03.lci.lasalle.mx -RefreshPolicy | Format-Table
# Sin ComputerName, consulta todas las estaciones Windows habilitadas de AD.
.\scripts\Get-SguWorkstationRemoteManagementStatus.ps1 | Format-Table
```
Un cliente con canal seguro roto necesita primero reparar su relación de
confianza con credenciales autorizadas. No elimine su objeto de AD para forzar
la aplicación de una política. Un equipo apagado o sin conectividad recibirá
la configuración cuando vuelva a contactar con el dominio.
Las GPO habilitan la administración de las estaciones. El inventario de conexiones
de WAC se mantiene en el gateway y se registra por separado:
```powershell
.\scripts\Sync-SguWacDomainConnections.ps1 -Endpoint https://sgu-dc02/ `
-Credential (Get-Credential 'LCI\azureadmin') -DomainController SGU-DC02
```
El script usa el inicio de sesión nativo de WAC v2 mediante HTTPS, CSRF y
RSA-OAEP-SHA256. No cambia la autenticación ni almacena la contraseña. Añade
conexiones **compartidas** para las cuentas Windows habilitadas de AD que tengan
nombre DNS, conserva las conexiones existentes y verifica que no falte ninguna.
Si se repite, no vuelve a añadir las mismas conexiones. Ejecútelo de nuevo al
añadir equipos al dominio, o use **Agregar → Buscar en Active Directory** en WAC;
no hay un sondeo periódico instalado para mantener esta lista.
`-VerifyNodes AF-02.lci.lasalle.mx,AF-03.lci.lasalle.mx` comprueba además que el
gateway pueda consultar instancias del sistema operativo mediante su API CIM.
La presencia de una conexión en la lista no implica que esté encendida.
Desde un equipo administrador no unido al dominio, PowerShell Remoting por
HTTP requiere indicar `-Credential` y confiar explícitamente en el destino
mediante `TrustedHosts`, o utilizar WinRM por HTTPS. `Test-WSMan` solo verifica
el listener; no inicia sesión. Las reglas locales de la estación no abren
puertos en Azure ni en el router del laboratorio.
+122
View File
@@ -0,0 +1,122 @@
[CmdletBinding()]
param(
[string]$ProfileName = 'Centro de Experiencia Digital',
[string]$Ssid = '',
[ValidateRange(1,30)][int]$TimeoutMinutes = 10,
[string]$FallbackProfile = '',
[string]$StatusPath = '',
[switch]$Force,
[switch]$RequireGroupPolicy
)
$ErrorActionPreference = 'Stop'
if (-not $Ssid) { $Ssid = $ProfileName }
# Connect to the already provisioned profile. Do not scan BSSIDs or change
# Windows location consent: those operations are unnecessary for this task.
if (-not ('Sgu.CedWlan' -as [type])) {
Add-Type -TypeDefinition @'
using System;
using System.Runtime.InteropServices;
namespace Sgu {
public static class CedWlan {
[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
public struct Parameters {
public int Mode;
[MarshalAs(UnmanagedType.LPWStr)] public string Profile;
public IntPtr Ssid;
public IntPtr Bssids;
public int BssType;
public uint Flags;
}
[DllImport("wlanapi.dll")] static extern uint WlanOpenHandle(uint version,IntPtr reserved,out uint negotiated,out IntPtr handle);
[DllImport("wlanapi.dll")] static extern uint WlanEnumInterfaces(IntPtr handle,IntPtr reserved,out IntPtr list);
[DllImport("wlanapi.dll",CharSet=CharSet.Unicode)] static extern uint WlanConnect(IntPtr handle,ref Guid id,ref Parameters parameters,IntPtr reserved);
[DllImport("wlanapi.dll",CharSet=CharSet.Unicode)] static extern uint WlanGetProfile(IntPtr handle,ref Guid id,string profile,IntPtr reserved,out IntPtr xml,ref uint flags,out uint access);
[DllImport("wlanapi.dll",CharSet=CharSet.Unicode)] static extern uint WlanSetProfile(IntPtr handle,ref Guid id,uint flags,string xml,string security,[MarshalAs(UnmanagedType.Bool)] bool overwrite,IntPtr reserved,out uint reason);
[DllImport("wlanapi.dll")] static extern uint WlanCloseHandle(IntPtr handle,IntPtr reserved);
[DllImport("wlanapi.dll")] static extern void WlanFreeMemory(IntPtr memory);
static void Check(uint result) { if(result!=0) throw new System.ComponentModel.Win32Exception((int)result); }
public static void Connect(string profile, bool requireGroupPolicy) {
IntPtr handle=IntPtr.Zero, list=IntPtr.Zero; uint version;
Check(WlanOpenHandle(2,IntPtr.Zero,out version,out handle));
try {
Check(WlanEnumInterfaces(handle,IntPtr.Zero,out list));
int count=Marshal.ReadInt32(list);
if(count==0) throw new InvalidOperationException("No WLAN interfaces.");
for(int i=0;i<count;i++) {
Guid id=(Guid)Marshal.PtrToStructure(IntPtr.Add(list,8+i*532),typeof(Guid));
// GP's CSE can leave a Personal key unprotected. Let Native Wi-Fi
// encrypt it for this machine while retaining the GP profile type.
IntPtr xmlPointer=IntPtr.Zero; uint flags=0, access;
Check(WlanGetProfile(handle,ref id,profile,IntPtr.Zero,out xmlPointer,ref flags,out access));
try {
if(requireGroupPolicy && (flags & 1)==0) throw new InvalidOperationException("The requested profile is not managed by Group Policy.");
string xml=Marshal.PtrToStringUni(xmlPointer);
if((flags & 1)!=0 && xml.Contains("<protected>false</protected>")) {
uint reason; Check(WlanSetProfile(handle,ref id,1,xml,null,true,IntPtr.Zero,out reason));
}
} finally { if(xmlPointer!=IntPtr.Zero) WlanFreeMemory(xmlPointer); }
Parameters p=new Parameters { Mode=0,Profile=profile,BssType=1,Flags=0 };
Check(WlanConnect(handle,ref id,ref p,IntPtr.Zero));
}
} finally { if(list!=IntPtr.Zero) WlanFreeMemory(list); WlanCloseHandle(handle,IntPtr.Zero); }
}
}
}
'@
}
$start = Get-Date
$deadline = $start.AddMinutes($TimeoutMinutes)
function Write-Status([string]$Status, $Details) {
if ($StatusPath) {
[pscustomobject]@{Time=Get-Date;Profile=$ProfileName;Status=$Status;Details=$Details} |
ConvertTo-Json -Depth 4 | Set-Content -LiteralPath $StatusPath -Encoding UTF8
}
}
if (-not $Force) {
$liveSsid = @()
try {
$connections = [Windows.Networking.Connectivity.NetworkInformation,Windows.Networking.Connectivity,ContentType=WindowsRuntime]::GetConnectionProfiles()
$liveSsid = @($connections | Where-Object IsWlanConnectionProfile | ForEach-Object { $_.WlanConnectionProfileDetails.GetConnectedSsid() })
} catch { # An unavailable SSID API means we must verify a fresh connection event.
}
$latest = Get-WinEvent -FilterHashtable @{
LogName='Microsoft-Windows-WLAN-AutoConfig/Operational';Id=8001,8003
} -MaxEvents 1 -ErrorAction SilentlyContinue
if ($liveSsid -contains $Ssid -and $latest -and $latest.Id -eq 8001) {
[xml]$latestXml = $latest.ToXml()
$data = $latestXml.Event.EventData.Data
if (@($data | Where-Object { $_.Name -eq 'SSID' -and $_.'#text' -eq $Ssid }).Count -and
@($data | Where-Object { $_.Name -eq 'ProfileName' -and $_.'#text' -eq $ProfileName }).Count) {
Write-Status 'AlreadyConnected' $null
return
}
}
}
try {
do {
[Sgu.CedWlan]::Connect($ProfileName,[bool]$RequireGroupPolicy)
Start-Sleep -Seconds 10
$connected = Get-WinEvent -FilterHashtable @{
LogName='Microsoft-Windows-WLAN-AutoConfig/Operational';Id=8001;StartTime=$start
} -MaxEvents 20 -ErrorAction SilentlyContinue | Where-Object {
[xml]$eventXml = $_.ToXml()
$eventData = $eventXml.Event.EventData.Data
@($eventData | Where-Object { $_.Name -eq 'SSID' -and $_.'#text' -eq $Ssid }).Count -gt 0 -and
@($eventData | Where-Object { $_.Name -eq 'ProfileName' -and $_.'#text' -eq $ProfileName }).Count -gt 0
}
if ($connected) {
Register-DnsClient -ErrorAction SilentlyContinue
Write-Status 'Connected' $null
return
}
} while ((Get-Date) -lt $deadline)
$failures = @(Get-WinEvent -FilterHashtable @{
LogName='Microsoft-Windows-WLAN-AutoConfig/Operational';Id=8002;StartTime=$start
} -MaxEvents 3 -ErrorAction SilentlyContinue | ForEach-Object Message)
Write-Status 'Failed' $failures
throw "No successful WLAN connection event for '$ProfileName' within $TimeoutMinutes minutes."
} catch {
Write-Status 'Failed' $_.Exception.Message
if ($FallbackProfile) { [Sgu.CedWlan]::Connect($FallbackProfile,$false) }
throw
}
+21 -2
View File
@@ -202,15 +202,33 @@ if ($RemoteDesktopGroupDn) {
} }
$managedUsersPasswordChangeCorrected = 0 $managedUsersPasswordChangeCorrected = 0
$managedUsersReversibleEncryptionDisabled = 0
$sguRoleGroupDns = @($ProfessorGroupDn, $StudentGroupDn, $AdministrativeGroupDn)
$sguRoleUserDns = [Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
foreach ($roleGroupDn in $sguRoleGroupDns) {
foreach ($member in Get-ADGroupMember -Identity $roleGroupDn -Recursive `
-Server $LdapHost -ErrorAction Stop) {
if ($member.objectClass -eq 'user') {
[void]$sguRoleUserDns.Add($member.DistinguishedName)
}
}
}
if ($PSCmdlet.ShouldProcess($usersOuDn, 'Deny direct password changes for every managed SGU user')) { if ($PSCmdlet.ShouldProcess($usersOuDn, 'Deny direct password changes for every managed SGU user')) {
$managedUsers = @(Get-ADUser -Filter * -SearchBase $usersOuDn -SearchScope Subtree ` $managedUsers = @(Get-ADUser -Filter * -SearchBase $usersOuDn -SearchScope Subtree `
-Properties CannotChangePassword -Server $LdapHost -ErrorAction Stop) -Properties CannotChangePassword,AllowReversiblePasswordEncryption `
-Server $LdapHost -ErrorAction Stop)
foreach ($managedUser in $managedUsers) { foreach ($managedUser in $managedUsers) {
if (-not $managedUser.CannotChangePassword) { if (-not $managedUser.CannotChangePassword) {
Set-ADAccountControl -Identity $managedUser.DistinguishedName ` Set-ADAccountControl -Identity $managedUser.DistinguishedName `
-CannotChangePassword $true -Server $LdapHost -Confirm:$false -CannotChangePassword $true -Server $LdapHost -Confirm:$false
$managedUsersPasswordChangeCorrected++ $managedUsersPasswordChangeCorrected++
} }
if ($sguRoleUserDns.Contains($managedUser.DistinguishedName) -and
$managedUser.AllowReversiblePasswordEncryption) {
Set-ADAccountControl -Identity $managedUser.DistinguishedName `
-AllowReversiblePasswordEncryption $false -Server $LdapHost -Confirm:$false
$managedUsersReversibleEncryptionDisabled++
}
} }
} }
@@ -370,4 +388,5 @@ if ($PSCmdlet.ShouldProcess($installPath, 'Install the SGU Authentication Broker
Get-Service -Name $serviceName | Select-Object Name, Status, StartType, Get-Service -Name $serviceName | Select-Object Name, Status, StartType,
@{ Name = 'EventLog'; Expression = { $brokerEventLogName } }, @{ Name = 'EventLog'; Expression = { $brokerEventLogName } },
@{ Name = 'ExistingUsersPasswordChangeDenied'; Expression = { $managedUsersPasswordChangeCorrected } } @{ Name = 'ExistingUsersPasswordChangeDenied'; Expression = { $managedUsersPasswordChangeCorrected } },
@{ Name = 'ExistingSguRoleUsersReversibleEncryptionDisabled'; Expression = { $managedUsersReversibleEncryptionDisabled } }
@@ -0,0 +1,105 @@
[CmdletBinding()]
param()
$ErrorActionPreference = 'Stop'
$computer = Get-CimInstance Win32_ComputerSystem
if (-not $computer.PartOfDomain -or $computer.DomainRole -ge 4) { return }
# The domain's Builtin\Administrators group is not the local Administrators
# group on a member workstation, even though both have SID S-1-5-32-544.
# Resolve its *users* through LDAP, then grant their domain SIDs locally.
# The directory lookup must succeed before any local membership is changed.
$domainDn = 'DC=' + (($computer.Domain -split '\.') -join ',DC=')
$domainAdministratorsDn = "CN=Administrators,CN=Builtin,$domainDn"
$directoryRoot = [DirectoryServices.DirectoryEntry]::new("LDAP://$domainDn")
$searcher = [DirectoryServices.DirectorySearcher]::new($directoryRoot)
$searcher.Filter = "(&(objectCategory=person)(objectClass=user)(memberOf:1.2.840.113556.1.4.1941:=$domainAdministratorsDn))"
$searcher.PageSize = 500
$searcher.ClientTimeout = [TimeSpan]::FromSeconds(5)
$searcher.ServerTimeLimit = [TimeSpan]::FromSeconds(5)
[void]$searcher.PropertiesToLoad.Add('objectSid')
try {
$results = $searcher.FindAll()
try {
$desiredSids = @(
foreach ($result in $results) {
$sidBytes = [byte[]]$result.Properties['objectsid'][0]
if ($sidBytes.Length -gt 0) {
[Security.Principal.SecurityIdentifier]::new($sidBytes, 0).Value
}
}
) | Sort-Object -Unique
}
finally { $results.Dispose() }
}
catch {
Write-Warning "Cannot read domain Administrators; local membership was left unchanged: $($_.Exception.Message)"
return
}
finally {
$searcher.Dispose()
$directoryRoot.Dispose()
}
$localAdministratorsSid = [Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
$localAdministrators = Get-LocalGroup -SID $localAdministratorsSid
$group = [ADSI]("WinNT://$env:COMPUTERNAME/$($localAdministrators.Name),group")
function Get-MemberSids {
@($group.psbase.Invoke('Members') | ForEach-Object {
try {
$bytes = $_.GetType().InvokeMember('objectSid',
[Reflection.BindingFlags]::GetProperty, $null, $_, $null)
if ($bytes) {
[Security.Principal.SecurityIdentifier]::new([byte[]]$bytes, 0).Value
}
}
catch { }
})
}
$statePath = 'HKLM:\SOFTWARE\SGU\WorkstationAdministrators'
$managedSids = if (Test-Path -LiteralPath $statePath) {
@((Get-ItemProperty -LiteralPath $statePath -Name ManagedSids -ErrorAction SilentlyContinue).ManagedSids)
} else { @() }
$managedSids = @($managedSids | Where-Object { $_ -match '^S-1-5-21-' } | Sort-Object -Unique)
$presentSids = @(Get-MemberSids)
foreach ($sid in $desiredSids) {
if ($presentSids -notcontains $sid) {
Add-LocalGroupMember -Group $localAdministrators.Name -Member $sid
$presentSids += $sid
$managedSids += $sid
}
}
# Remove only entries previously added by this policy. Other local or domain
# administrators remain untouched if they have a separate authorization path.
foreach ($sid in @($managedSids | Where-Object { $desiredSids -notcontains $_ })) {
if ($presentSids -contains $sid) {
Remove-LocalGroupMember -Group $localAdministrators.Name -Member $sid
}
}
New-Item -Path $statePath -Force | Out-Null
$remainingManagedSids = @($managedSids |
Where-Object { $desiredSids -contains $_ } | Sort-Object -Unique)
if ($remainingManagedSids.Count -gt 0) {
$state = @{
Path = $statePath
Name = 'ManagedSids'
PropertyType = 'MultiString'
Value = $remainingManagedSids
Force = $true
}
New-ItemProperty @state | Out-Null
}
else {
Remove-ItemProperty -Path $statePath -Name ManagedSids -ErrorAction SilentlyContinue
}
$verifiedSids = @(Get-MemberSids)
$missingSids = @($desiredSids | Where-Object { $verifiedSids -notcontains $_ })
if ($missingSids.Count -gt 0) {
throw "Domain Administrators were not added to local Administrators: $($missingSids -join ', ')"
}
@@ -0,0 +1,142 @@
[CmdletBinding()]
param(
[string]$RemoteDesktopPrincipal = 'LCI\SG-Laboratorio-Usuarios-RDP',
[string]$LocalDnsServer = '',
[string]$FallbackDnsServer = ''
)
$ErrorActionPreference = 'Stop'
$computer = Get-CimInstance Win32_ComputerSystem
if (-not $computer.PartOfDomain -or $computer.DomainRole -ne 1) { return }
# A site-local DNS server is optional. Change only an adapter whose directly
# connected subnet contains that server, after verifying its authoritative DNS
# answer. Other sites, VPN adapters and Internet-only interfaces are preserved.
if ($LocalDnsServer) {
$dnsBytes = ([Net.IPAddress]::Parse($LocalDnsServer)).GetAddressBytes()
foreach ($ip in @(Get-NetIPAddress -AddressFamily IPv4 | Where-Object {
$_.AddressState -eq 'Preferred' -and $_.PrefixLength -gt 0 -and $_.PrefixLength -lt 32
})) {
$ipBytes = ([Net.IPAddress]::Parse($ip.IPAddress)).GetAddressBytes()
$sameSubnet = $true
for ($bit = 0; $bit -lt $ip.PrefixLength; $bit++) {
$mask = 1 -shl (7 - ($bit % 8))
$index = [int][Math]::Floor($bit / 8)
if (($ipBytes[$index] -band $mask) -ne ($dnsBytes[$index] -band $mask)) {
$sameSubnet = $false; break
}
}
if (-not $sameSubnet) { continue }
try {
$authority = @(Resolve-DnsName -Name $computer.Domain -Type SOA -Server $LocalDnsServer -DnsOnly -ErrorAction Stop |
Where-Object { $_.Name -ieq $computer.Domain -and $_.Type -eq 'SOA' })
if (-not $authority) { throw 'The DNS server did not return the domain SOA.' }
$desiredServers = @($LocalDnsServer)
if ($FallbackDnsServer) {
[Net.IPAddress]::Parse($FallbackDnsServer) | Out-Null
$fallbackAuthority = @(Resolve-DnsName -Name $computer.Domain -Type SOA -Server $FallbackDnsServer -DnsOnly -ErrorAction Stop |
Where-Object { $_.Name -ieq $computer.Domain -and $_.Type -eq 'SOA' })
if (-not $fallbackAuthority) { throw 'Fallback DNS is not authoritative for this domain.' }
$desiredServers += $FallbackDnsServer
}
$current = (Get-DnsClientServerAddress -InterfaceIndex $ip.InterfaceIndex -AddressFamily IPv4).ServerAddresses
if ((@($current) -join ',') -ne ($desiredServers -join ',')) {
Set-DnsClientServerAddress -InterfaceIndex $ip.InterfaceIndex -ServerAddresses $desiredServers
}
Set-DnsClient -InterfaceIndex $ip.InterfaceIndex -RegisterThisConnectionsAddress $true
Register-DnsClient
} catch { Write-Warning "Site DNS configuration failed: $($_.Exception.Message)" }
}
}
$terminalKey = 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server'
$rdpKey = Join-Path $terminalKey 'WinStations\RDP-Tcp'
if ((Get-ItemPropertyValue -Path $terminalKey -Name fDenyTSConnections) -ne 0) {
Set-ItemProperty -Path $terminalKey -Name fDenyTSConnections -Value 0
}
if ((Get-ItemPropertyValue -Path $rdpKey -Name UserAuthentication) -ne 1) {
Set-ItemProperty -Path $rdpKey -Name UserAuthentication -Value 1
}
foreach ($name in @('TermService', 'WinRM')) {
$service = Get-Service -Name $name
if ($service.StartType -ne 'Automatic') { Set-Service -Name $name -StartupType Automatic }
if ($service.Status -ne 'Running') { Start-Service -Name $name }
}
# Each domain refresh carries this script through SYSVOL. Apply only the
# narrowly scoped inbound rules required by an administrator on the same LAN.
$rules = @(
@{ Name = 'SGU-Workstation-WinRM-HTTP'; Protocol = 'TCP'; Port = '5985' },
@{ Name = 'SGU-Workstation-RDP-TCP'; Protocol = 'TCP'; Port = '3389' },
@{ Name = 'SGU-Workstation-RDP-UDP'; Protocol = 'UDP'; Port = '3389' }
)
foreach ($rule in $rules) {
$existing = Get-NetFirewallRule -Name $rule.Name -ErrorAction SilentlyContinue
if ($existing) {
$port = $existing | Get-NetFirewallPortFilter
$address = $existing | Get-NetFirewallAddressFilter
$valid = $existing.Enabled -eq 'True' -and $existing.Action -eq 'Allow' -and
$existing.Direction -eq 'Inbound' -and $existing.Profile -eq 'Any' -and
$port.Protocol -eq $rule.Protocol -and [string]$port.LocalPort -eq $rule.Port -and
@($address.RemoteAddress).Count -eq 1 -and $address.RemoteAddress -eq 'LocalSubnet'
if ($valid) { continue }
$existing | Remove-NetFirewallRule
}
New-NetFirewallRule -Name $rule.Name -DisplayName $rule.Name -Enabled True `
-Direction Inbound -Action Allow -Profile Any -Protocol $rule.Protocol `
-LocalPort $rule.Port -RemoteAddress LocalSubnet | Out-Null
}
# WinRM's administrative-template policy creates the listener. This also
# restores the Windows PowerShell session endpoint when it was disabled.
$listener = @(Get-ChildItem WSMan:\localhost\Listener -ErrorAction SilentlyContinue |
Where-Object { $_.Keys -contains 'Transport=HTTP' })
$endpoint = Get-PSSessionConfiguration -Name Microsoft.PowerShell -ErrorAction SilentlyContinue
$endpointEnabled = Get-Item 'WSMan:\localhost\Plugin\Microsoft.PowerShell\Enabled' -ErrorAction SilentlyContinue
if (-not $listener -or -not $endpoint -or $endpointEnabled.Value -eq 'false') {
Enable-PSRemoting -Force -SkipNetworkProfileCheck | Out-Null
}
# Native, language-independent rule names. The domain policy also distributes
# these rules through the firewall CSE, so background gpupdate can repair them.
$managementPatterns = @('RemoteEventLogSvc-*', 'RemoteSvcAdmin-*', 'WMI-*',
'RemoteTask-*', 'RemoteFwAdmin-*', 'RVM-*', 'PerfLogsAlerts-*', 'FPS-SMB-In-TCP*')
foreach ($pattern in $managementPatterns) {
foreach ($nativeRule in @(Get-NetFirewallRule -Name $pattern -ErrorAction SilentlyContinue |
Where-Object Direction -eq 'Inbound')) {
# Do not try to mutate policy-owned rules in the workstation local store.
if ($nativeRule.PolicyStoreSourceType -ne 'Local') { continue }
$address = $nativeRule | Get-NetFirewallAddressFilter
if ($nativeRule.Enabled -ne 'True' -or $nativeRule.Profile -ne 'Any' -or
@($address.RemoteAddress).Count -ne 1 -or $address.RemoteAddress[0] -ne 'LocalSubnet') {
$nativeRule | Set-NetFirewallRule -Enabled True -Profile Any -RemoteAddress LocalSubnet
}
}
}
$remoteRegistry = Get-Service RemoteRegistry
if ($remoteRegistry.StartType -ne 'Manual') { Set-Service RemoteRegistry -StartupType Manual }
# The built-in local group has a stable SID across Windows display languages.
$groupSid = [Security.Principal.SecurityIdentifier]::new('S-1-5-32-555')
$groupName = ($groupSid.Translate([Security.Principal.NTAccount]).Value -split '\\', 2)[1]
try {
$principalSid = ([Security.Principal.NTAccount]::new($RemoteDesktopPrincipal)).Translate(
[Security.Principal.SecurityIdentifier]).Value
$group = [ADSI]("WinNT://$env:COMPUTERNAME/$groupName,group")
$memberSids = @($group.psbase.Invoke('Members') | ForEach-Object {
try {
$bytes = $_.GetType().InvokeMember('objectSid',
[Reflection.BindingFlags]::GetProperty, $null, $_, $null)
if ($bytes) { ([Security.Principal.SecurityIdentifier]::new([byte[]]$bytes, 0)).Value }
}
catch { }
})
if ($memberSids -notcontains $principalSid) {
Add-LocalGroupMember -Group $groupName -Member $principalSid
}
}
catch {
# A temporarily unavailable DC must not prevent RDP and WinRM from starting.
Write-Warning "Remote Desktop group membership could not be verified: $($_.Exception.Message)"
}
+6
View File
@@ -29,10 +29,16 @@ $eventNames = @{
1202 = 'ProfileEnrichmentTimeout' 1202 = 'ProfileEnrichmentTimeout'
1203 = 'ProfileEnrichmentFailure' 1203 = 'ProfileEnrichmentFailure'
1204 = 'ProfilePageUnavailable' 1204 = 'ProfilePageUnavailable'
1205 = 'ProfilePhotoUnavailable'
1206 = 'ProfilePhotoInvalid'
1300 = 'DirectorySynchronizationFailure' 1300 = 'DirectorySynchronizationFailure'
1301 = 'DirectoryOptionalMetadataFailure' 1301 = 'DirectoryOptionalMetadataFailure'
1302 = 'DirectoryGroupMembershipFailure' 1302 = 'DirectoryGroupMembershipFailure'
1303 = 'DirectoryRoleGroupMembershipAdded' 1303 = 'DirectoryRoleGroupMembershipAdded'
1304 = 'DirectoryPasswordChangeDenied'
1305 = 'DirectoryPhotoFailure'
1306 = 'DirectoryReversiblePasswordEncryptionEnabled'
1307 = 'DirectoryReversiblePasswordEncryptionDisabled'
} }
# Keep these reads unfiltered. Besides making archived and current logs behave # Keep these reads unfiltered. Besides making archived and current logs behave
@@ -0,0 +1,39 @@
[CmdletBinding()]
param(
[string[]]$ComputerName,
[PSCredential]$Credential,
[string]$DomainController = $env:COMPUTERNAME,
[switch]$RefreshPolicy
)
$ErrorActionPreference = 'Stop'
if (-not $ComputerName) {
Import-Module ActiveDirectory
$ComputerName = @(Get-ADComputer -Server $DomainController -Filter 'Enabled -eq $true' -Properties OperatingSystem,DNSHostName |
Where-Object { $_.DNSHostName -and $_.OperatingSystem -like 'Windows*' -and $_.OperatingSystem -notlike '*Server*' } |
Select-Object -ExpandProperty DNSHostName)
}
foreach ($name in $ComputerName) {
try {
$parameters = @{ComputerName=$name;Authentication='Kerberos';ErrorAction='Stop';
SessionOption=(New-PSSessionOption -OpenTimeout 10000 -OperationTimeout 90000)}
if ($Credential) { $parameters.Credential = $Credential }
Invoke-Command @parameters -ArgumentList ([bool]$RefreshPolicy) -ScriptBlock {
param($refresh)
$exitCode = $null
if ($refresh) { gpupdate /target:computer /force /wait:60 | Out-Null; $exitCode=$LASTEXITCODE }
$rules = @(Get-NetFirewallRule -PolicyStore ActiveStore -Name 'LaSalle-Management-*' -ErrorAction SilentlyContinue |
Where-Object { $_.PolicyStoreSourceType -eq 'GroupPolicy' -and $_.Enabled -eq 'True' })
$applied = @(Get-CimInstance -Namespace root\RSOP\Computer -ClassName RSOP_GPO)
[pscustomobject]@{
Name=$env:COMPUTERNAME; Reachable=$true; SecureChannel=(Test-ComputerSecureChannel)
PolicyApplied=($applied.Name -contains 'La Salle - Workstation remote management')
RdpEnabled=((Get-ItemPropertyValue 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server' -Name fDenyTSConnections) -eq 0)
NLA=((Get-ItemPropertyValue 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp' -Name UserAuthentication) -eq 1)
WinRM=[string](Get-Service WinRM).Status; RdpService=[string](Get-Service TermService).Status
PolicyFirewallRules=$rules.Count; GpUpdateExit=$exitCode
}
} | Select-Object Name,Reachable,SecureChannel,PolicyApplied,RdpEnabled,NLA,WinRM,RdpService,PolicyFirewallRules,GpUpdateExit
} catch {
[pscustomobject]@{Name=$name;Reachable=$false;Error=$_.Exception.Message}
}
}
@@ -518,7 +518,12 @@ foreach ($requiredPath in @(
(Join-Path $scriptsRoot 'Deploy-AuthBroker.ps1'), (Join-Path $scriptsRoot 'Deploy-AuthBroker.ps1'),
(Join-Path $scriptsRoot 'New-LabCertificate.ps1'), (Join-Path $scriptsRoot 'New-LabCertificate.ps1'),
(Join-Path $scriptsRoot 'Set-LabBrokerDns.ps1'), (Join-Path $scriptsRoot 'Set-LabBrokerDns.ps1'),
(Join-Path $scriptsRoot 'Set-SguInstitutionalPasswordPolicy.ps1'),
(Join-Path $scriptsRoot 'Set-SguDomainComputerPolicies.ps1'), (Join-Path $scriptsRoot 'Set-SguDomainComputerPolicies.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationRemoteAccess.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationAdministrators.ps1'),
(Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1'),
(Join-Path $scriptsRoot 'Install-SguDomainRemoteManagementPolicy.ps1'),
(Join-Path $scriptsRoot 'Set-SguDomainUserPolicies.ps1'), (Join-Path $scriptsRoot 'Set-SguDomainUserPolicies.ps1'),
(Join-Path $scriptsRoot 'Set-SguLaboratorioWallpaperPolicy.ps1'), (Join-Path $scriptsRoot 'Set-SguLaboratorioWallpaperPolicy.ps1'),
(Join-Path $scriptsRoot 'Enable-SguServerRemoteManagement.ps1'), (Join-Path $scriptsRoot 'Enable-SguServerRemoteManagement.ps1'),
@@ -771,6 +776,9 @@ if (Test-Path -LiteralPath $brokerConfigurationPath -PathType Leaf) {
-CreateMissingOus ` -CreateMissingOus `
-DisableCertificateRevocationCheckForLab | Out-Null -DisableCertificateRevocationCheckForLab | Out-Null
& (Join-Path $scriptsRoot 'Set-SguInstitutionalPasswordPolicy.ps1') `
-BaseDn $baseDn -DomainController $adServer | Out-Null
# Remove stale A records registered by any non-domain/NAT adapter before its # Remove stale A records registered by any non-domain/NAT adapter before its
# dynamic DNS registration was disabled. # dynamic DNS registration was disabled.
$hostRecords = @(Get-DnsServerResourceRecord -ZoneName $DomainName ` $hostRecords = @(Get-DnsServerResourceRecord -ZoneName $DomainName `
@@ -820,6 +828,12 @@ $collectorFqdn = "$env:COMPUTERNAME.$DomainName"
-TargetOuDn $laboratoryOuDn ` -TargetOuDn $laboratoryOuDn `
-DomainController $env:COMPUTERNAME ` -DomainController $env:COMPUTERNAME `
-EventCollectorFqdn $collectorFqdn | Out-Null -EventCollectorFqdn $collectorFqdn | Out-Null
& (Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1') `
-TargetOuDn $laboratoryOuDn `
-DomainController $env:COMPUTERNAME | Out-Null
& (Join-Path $scriptsRoot 'Install-SguDomainRemoteManagementPolicy.ps1') `
-DomainController $env:COMPUTERNAME | Out-Null
& (Join-Path $scriptsRoot 'Install-SguDomainMonitoring.ps1') ` & (Join-Path $scriptsRoot 'Install-SguDomainMonitoring.ps1') `
-CollectorFqdn $collectorFqdn ` -CollectorFqdn $collectorFqdn `
-ComputerOuDn $laboratoryOuDn ` -ComputerOuDn $laboratoryOuDn `
+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
+65
View File
@@ -0,0 +1,65 @@
[CmdletBinding()]
param()
$ErrorActionPreference = 'Stop'
# Native WLAN AutoConfig holds the machine profile before interactive logon.
$computer=Get-CimInstance Win32_ComputerSystem
if(-not $computer.PartOfDomain -or $computer.DomainRole -ne 1 -or $env:COMPUTERNAME -notmatch '^(AF|SD|SI)-'){return}
$destination = 'C:\ProgramData\LCI-Admin\CED-WiFi'
New-Item $destination -ItemType Directory -Force | Out-Null
$acl = [Security.AccessControl.DirectorySecurity]::new()
$acl.SetAccessRuleProtection($true,$false)
foreach ($sid in 'S-1-5-18','S-1-5-32-544') {
$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new(
[Security.Principal.SecurityIdentifier]::new($sid),'FullControl','ContainerInherit,ObjectInherit','None','Allow'))
}
if((Get-Acl -LiteralPath $destination).GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access) -ne $acl.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)){Set-Acl -LiteralPath $destination -AclObject $acl}
$source=Join-Path $PSScriptRoot 'Repair-SguCedWifi.ps1'
$helper=Join-Path $destination 'Repair-SguCedWifi.ps1'
if($source -ine $helper -and (-not(Test-Path -LiteralPath $helper) -or (Get-FileHash -LiteralPath $source).Hash -ne (Get-FileHash -LiteralPath $helper).Hash)){Copy-Item -LiteralPath $source -Destination $helper -Force}
$service=Get-Service WlanSvc
if($service.StartType -ne 'Automatic'){Set-Service WlanSvc -StartupType Automatic}
if($service.Status -ne 'Running'){Start-Service WlanSvc}
$subscription='<QueryList><Query Id="0" Path="Microsoft-Windows-GroupPolicy/Operational"><Select Path="Microsoft-Windows-GroupPolicy/Operational">*[System[(EventID=8000 or EventID=8002 or EventID=8004 or EventID=8006)]]</Select></Query><Query Id="1" Path="Microsoft-Windows-TerminalServices-LocalSessionManager/Operational"><Select Path="Microsoft-Windows-TerminalServices-LocalSessionManager/Operational">*[System[EventID=23]]</Select></Query><Query Id="2" Path="Microsoft-Windows-WLAN-AutoConfig/Operational"><Select Path="Microsoft-Windows-WLAN-AutoConfig/Operational">*[System[EventID=8001]]</Select></Query></QueryList>'
$subscription=[Security.SecurityElement]::Escape($subscription)
$command=[Security.SecurityElement]::Escape("$env:WINDIR\System32\WindowsPowerShell\v1.0\powershell.exe")
$arguments=[Security.SecurityElement]::Escape('-NoProfile -NonInteractive -ExecutionPolicy Bypass -File "'+$helper+'"')
$taskXml=@"
<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
<RegistrationInfo><Author>La Salle</Author><Description>Computer Wi-Fi recovery after boot, computer policy, logoff or network change. No periodic polling.</Description></RegistrationInfo>
<Triggers><BootTrigger><Enabled>true</Enabled><Delay>PT10S</Delay></BootTrigger><EventTrigger><Enabled>true</Enabled><Subscription>$subscription</Subscription><Delay>PT3S</Delay></EventTrigger></Triggers>
<Principals><Principal id="System"><UserId>S-1-5-18</UserId><RunLevel>HighestAvailable</RunLevel></Principal></Principals>
<Settings><MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy><DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries><StopIfGoingOnBatteries>false</StopIfGoingOnBatteries><StartWhenAvailable>true</StartWhenAvailable><RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable><Enabled>true</Enabled><ExecutionTimeLimit>PT1M</ExecutionTimeLimit></Settings>
<Actions Context="System"><Exec><Command>$command</Command><Arguments>$arguments</Arguments></Exec></Actions>
</Task>
"@
$taskName='CED WiFi policy connection'
$existing=Get-ScheduledTask -TaskName $taskName -ErrorAction SilentlyContinue
$versionFile=Join-Path $destination 'maintenance-v2.sha256'
$sha=[Security.Cryptography.SHA256]::Create()
try{$hash=[BitConverter]::ToString($sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($taskXml))).Replace('-','')}finally{$sha.Dispose()}
$valid=$existing -and $existing.Triggers.Count -eq 2 -and @($existing.Triggers|Where-Object{$_.Repetition.Interval}).Count -eq 0 -and $existing.Principal.UserId -in 'SYSTEM','S-1-5-18' -and (Test-Path -LiteralPath $versionFile) -and (Get-Content -LiteralPath $versionFile -Raw).Trim() -eq $hash
if(-not $valid){Register-ScheduledTask -TaskName $taskName -Xml $taskXml -Force|Out-Null;$hash|Set-Content -LiteralPath $versionFile -Encoding ASCII}
$profileState=& $helper
if(-not $profileState.MachineProfileReady){
# Computer authentication reads the existing restricted AD WLAN object.
# The PSK stays in memory and Windows encrypts it into its machine store.
$searchRoot=$null;$searcher=$null
try{
# Serverless LDAP can select Azure's private DC address, which these clients
# cannot route to. Use the local DC with signed and sealed machine binding.
$domainDn=($computer.Domain.Split('.')|ForEach-Object{'DC='+$_}) -join ','
$searchRoot=[DirectoryServices.DirectoryEntry]::new('LDAP://192.168.54.211/CN=Policies,CN=System,'+$domainDn)
$searchRoot.AuthenticationType=[DirectoryServices.AuthenticationTypes]::Secure -bor [DirectoryServices.AuthenticationTypes]::Signing -bor [DirectoryServices.AuthenticationTypes]::Sealing
$searcher=[DirectoryServices.DirectorySearcher]::new($searchRoot)
$searcher.Filter='(&(objectClass=ms-net-ieee-80211-GroupPolicy)(cn=CED Wi-Fi))'
[void]$searcher.PropertiesToLoad.Add('ms-net-ieee-80211-GP-PolicyData')
$found=@($searcher.FindAll())
if($found.Count -ne 1){throw 'Expected exactly one authorized CED WLAN policy.'}
[xml]$policy=[string]$found[0].Properties['ms-net-ieee-80211-gp-policydata'][0]
$profile=$policy.SelectSingleNode('//*[local-name()="WLANProfile"]')
$profileState=& $helper -ProvisionXml $profile.OuterXml
}finally{if($searcher){$searcher.Dispose()};if($searchRoot){$searchRoot.Dispose()};$profile=$null;$policy=$null}
}
if(-not $profileState.MachineProfileReady){throw 'Machine Wi-Fi profile is not ready.'}
Start-ScheduledTask -TaskName $taskName
@@ -0,0 +1,190 @@
[CmdletBinding(SupportsShouldProcess)]
param(
[string]$Version = '0.6.21',
[ValidatePattern('^https://')]
[string]$ClientPackageUri = 'https://gitea.lci.ulsa.mx/alexrg/SGU-CredentialProvider/releases/download/v0.6.21/sgu-windows-client-bootstrap-0.6.21.zip',
[ValidatePattern('^[0-9A-Fa-f]{64}$')]
[string]$ClientPackageSha256 = '59E2ECCB16A951D5A55D005325B734501868BFB2CFCFEF507A0FE8A1F829C21E',
[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'
$scriptsIniPath = Join-Path $gpoScriptsPath 'scripts.ini'
$legacyPowerShellScriptsIniPath = 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
}
# Windows remembers the provider used at the last interactive logon. Select
# the institutional tile at startup while leaving the native password tile
# registered for manual recovery.
`$logonUiPath = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Authentication\LogonUI'
Set-ItemProperty -Path `$logonUiPath -Name LastLoggedOnProvider -Value '{D789CFD8-5AD4-489F-9B83-7EB5D9D09335}'
`$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
}
New-Item -ItemType Directory -Path `$stagePath -Force | Out-Null
Add-Type -AssemblyName System.IO.Compression.FileSystem
[IO.Compression.ZipFile]::ExtractToDirectory(`$archivePath, `$stagePath)
}
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 = Join-Path `$env:ProgramFiles 'dotnet\dotnet.exe'
`$runtimeInstalled = (Test-Path -LiteralPath `$dotnet -PathType Leaf) -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))
$scriptUncPath = "\\$domainDnsRoot\SYSVOL\$domainDnsRoot\Policies\{$($gpo.Id)}\Machine\Scripts\Startup\$scriptName"
$scriptsIni = "[Startup]`r`n0CmdLine=powershell.exe`r`n0Parameters=-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$scriptUncPath`"`r`n"
# The Scripts CSE requires UTF-16LE with a BOM. The explicit process
# execution policy allows the verified installer to run on Windows clients
# whose default PowerShell policy is Restricted.
[IO.File]::WriteAllText($scriptsIniPath, $scriptsIni, [Text.Encoding]::Unicode)
if (Test-Path -LiteralPath $legacyPowerShellScriptsIniPath -PathType Leaf) {
Remove-Item -LiteralPath $legacyPowerShellScriptsIniPath -Force
}
# Writing SYSVOL directly does not register the Scripts CSE in the GPO's
# Active Directory object. Without it, gpresult lists the GPO but the
# client never executes its startup script.
$gpoDn = "CN={$($gpo.Id)},CN=Policies,CN=System,$domainDn"
$gpoObject = Get-ADObject -Identity $gpoDn -Server $DomainController `
-Properties gPCMachineExtensionNames,versionNumber
$scriptExtension = '[{42B5FAAE-6536-11D2-AE5A-0000F87571E3}{40B6664F-4972-11D1-A7CA-0000F87571E3}]'
$extensionNames = [string]$gpoObject.gPCMachineExtensionNames
if ($extensionNames.IndexOf($scriptExtension, [StringComparison]::OrdinalIgnoreCase) -lt 0) {
Set-ADObject -Identity $gpoDn -Server $DomainController `
-Replace @{gPCMachineExtensionNames = "$extensionNames$scriptExtension"}
}
# Keep the AD and SYSVOL computer versions synchronized and force clients
# to process this corrected script registration on their next refresh.
$gptIniPath = Join-Path (Split-Path (Split-Path $gpoScriptsPath -Parent) -Parent) 'GPT.ini'
$gptIni = Get-Content -LiteralPath $gptIniPath -Raw
$gptVersion = [int]([regex]::Match($gptIni, '(?m)^Version=(\d+)\r?$').Groups[1].Value)
$adVersion = [int]$gpoObject.versionNumber
$baseVersion = [Math]::Max($gptVersion, $adVersion)
$nextVersion = ($baseVersion -band -65536) -bor (($baseVersion + 1) -band 65535)
$updatedGptIni = [regex]::Replace($gptIni, '(?m)^Version=\d+\r?$', "Version=$nextVersion")
[IO.File]::WriteAllText($gptIniPath, $updatedGptIni, [Text.Encoding]::ASCII)
Set-ADObject -Identity $gpoDn -Server $DomainController -Replace @{versionNumber = $nextVersion}
}
[pscustomobject]@{
GpoName = $gpo.DisplayName
GpoId = $gpo.Id
LinkedTarget = $domainDn
StartupScript = $scriptPath
Version = $Version
PackageSha256 = $ClientPackageSha256.ToUpperInvariant()
}
@@ -0,0 +1,195 @@
[CmdletBinding()]
param(
[string]$GpoName = 'La Salle - Workstation remote management',
[string]$DomainController = $env:COMPUTERNAME,
[string[]]$ManagementAddresses = @('LocalSubnet'),
[string]$LocalDnsServer = '',
[string]$FallbackDnsServer = ''
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
Import-Module GroupPolicy
Import-Module NetSecurity
$domain = Get-ADDomain -Server $DomainController
$dnsRoot = $domain.DNSRoot
$domainDn = $domain.DistinguishedName
$gpo = Get-GPO -Name $GpoName -Domain $dnsRoot -Server $DomainController -ErrorAction SilentlyContinue
$changes = [Collections.Generic.List[string]]::new()
if (-not $gpo) {
$gpo = New-GPO -Name $GpoName -Domain $dnsRoot -Server $DomainController
$changes.Add('Created GPO')
}
if ($gpo.GpoStatus -ne 'UserSettingsDisabled') {
$gpo.GpoStatus = [Microsoft.GroupPolicy.GpoStatus]::UserSettingsDisabled
$changes.Add('Computer settings only')
}
$policyDn = "CN={$($gpo.Id)},CN=Policies,CN=System,$domainDn"
$policyRoot = Join-Path $env:WINDIR "SYSVOL\domain\Policies\{$($gpo.Id)}"
# Domain-root inheritance includes newly joined computers in CN=Computers.
# The WMI filter limits the policy to workstation OSes (Windows 10 and 11).
$filterName = 'La Salle - Windows workstations'
$filter = Get-ADObject -Server $DomainController -SearchBase "CN=SOM,CN=WMIPolicy,CN=System,$domainDn" `
-LDAPFilter '(objectClass=msWMI-Som)' -Properties msWMI-Name,msWMI-ID,msWMI-Parm2 |
Where-Object { $_.'msWMI-Name' -eq $filterName }
$query = 'SELECT * FROM Win32_OperatingSystem WHERE ProductType = 1'
$encodedQuery = "1;3;10;$($query.Length);WQL;root\CIMv2;$query;"
if (@($filter).Count -gt 1) { throw 'Duplicate workstation WMI filters; inspect before editing.' }
if (-not $filter) {
$filterId = '{' + [guid]::NewGuid().ToString().ToUpperInvariant() + '}'
$timestamp = (Get-Date).ToUniversalTime().ToString('yyyyMMddHHmmss.ffffff-000')
$filter = New-ADObject -Server $DomainController -Name $filterId -Type msWMI-Som `
-Path "CN=SOM,CN=WMIPolicy,CN=System,$domainDn" -OtherAttributes @{
'msWMI-Name' = $filterName; 'msWMI-ID' = $filterId
'msWMI-Parm1' = 'Domain workstation management; excludes servers and DCs.'
'msWMI-Parm2' = $encodedQuery; 'msWMI-Author' = 'Domain administrators'
'msWMI-CreationDate' = $timestamp; 'msWMI-ChangeDate' = $timestamp
} -PassThru
$filter = Get-ADObject $filter.DistinguishedName -Server $DomainController -Properties msWMI-ID
$changes.Add('Created workstation filter')
} elseif ($filter.'msWMI-Parm2' -ne $encodedQuery) {
throw 'Existing workstation filter has a different query; inspect before changing it.'
}
$filterReference = "[$dnsRoot;$($filter.'msWMI-ID');0]"
$policy = Get-ADObject $policyDn -Server $DomainController -Properties gPCWQLFilter
if ($policy.gPCWQLFilter -ne $filterReference) {
Set-ADObject $policyDn -Server $DomainController -Replace @{gPCWQLFilter=$filterReference}
$changes.Add('Linked workstation filter')
}
$registry = @(
@{Key='HKLM\Software\Policies\Microsoft\Windows NT\Terminal Services'; Name='fDenyTSConnections'; Type='DWord'; Value=0},
@{Key='HKLM\Software\Policies\Microsoft\Windows NT\Terminal Services'; Name='UserAuthentication'; Type='DWord'; Value=1},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WinRM\Service'; Name='AllowAutoConfig'; Type='DWord'; Value=1},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WinRM\Service'; Name='IPv4Filter'; Type='String'; Value='*'},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WinRM\Service'; Name='IPv6Filter'; Type='String'; Value='*'},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WinRM\Service\WinRS'; Name='AllowRemoteShellAccess'; Type='DWord'; Value=1}
)
foreach ($setting in $registry) {
$current = Get-GPRegistryValue -Name $GpoName -Domain $dnsRoot -Server $DomainController `
-Key $setting.Key -ValueName $setting.Name -ErrorAction SilentlyContinue
if (-not $current -or [string]$current.Value -ne [string]$setting.Value -or [string]$current.Type -ne $setting.Type) {
Set-GPRegistryValue -Name $GpoName -Domain $dnsRoot -Server $DomainController `
-Key $setting.Key -ValueName $setting.Name -Type $setting.Type -Value $setting.Value | Out-Null
$changes.Add("Registry: $($setting.Name)")
}
}
# Firewall policy is enforced by the native firewall CSE, including gpupdate.
# RPC dynamic ports are restricted to their Windows service, not opened broadly.
$ruleDefinitions = @(
@{Name='WinRM'; Protocol='TCP'; Port='5985'; Service='WinRM'},
@{Name='RDP-TCP'; Protocol='TCP'; Port='3389'; Service='TermService'},
@{Name='RDP-UDP'; Protocol='UDP'; Port='3389'; Service='TermService'},
@{Name='RPC-Endpoint'; Protocol='TCP'; Port='RPCEPMap'; Service='RpcSs'},
@{Name='WMI'; Protocol='TCP'; Port='Any'; Service='winmgmt'},
@{Name='EventLog'; Protocol='TCP'; Port='RPC'; Service='EventLog'},
@{Name='Services'; Protocol='TCP'; Port='RPC'; Service='services.exe'; Program='%SystemRoot%\System32\services.exe'},
@{Name='Tasks'; Protocol='TCP'; Port='RPC'; Service='Schedule'},
@{Name='Firewall'; Protocol='TCP'; Port='RPC'; Service='MpsSvc'},
@{Name='Volumes'; Protocol='TCP'; Port='RPC'; Service='vds'},
@{Name='Performance'; Protocol='TCP'; Port='RPC'; Service='pla'},
@{Name='SMB'; Protocol='TCP'; Port='445'; Service='LanmanServer'; Program='System'}
)
$session = Open-NetGPO -PolicyStore "$dnsRoot\$GpoName" -DomainController $DomainController
$firewallChanged = $false
foreach ($definition in $ruleDefinitions) {
$name = 'LaSalle-Management-' + $definition.Name
$program = '%SystemRoot%\System32\svchost.exe'
$service = $definition.Service
if ($definition.Program) { $program = $definition.Program }
if ($service -eq 'services.exe') { $service = 'Any' }
$existing = Get-NetFirewallRule -GPOSession $session -Name $name -ErrorAction SilentlyContinue
$valid = $false
if ($existing) {
$port = $existing | Get-NetFirewallPortFilter
$address = $existing | Get-NetFirewallAddressFilter
$application = $existing | Get-NetFirewallApplicationFilter
$svc = $existing | Get-NetFirewallServiceFilter
$valid = $existing.Enabled -eq 'True' -and $existing.Profile -eq 'Any' -and
$existing.Action -eq 'Allow' -and $existing.Direction -eq 'Inbound' -and
[string]$port.Protocol -eq $definition.Protocol -and [string]$port.LocalPort -eq $definition.Port -and
$application.Program -eq $program -and $svc.Service -eq $service -and
-not @(Compare-Object @($address.RemoteAddress) $ManagementAddresses).Count
}
if ($valid) { continue }
if ($existing) { $existing | Remove-NetFirewallRule }
New-NetFirewallRule -GPOSession $session -Name $name -DisplayName $name `
-Group 'La Salle remote management' -Enabled True -Direction Inbound -Action Allow `
-Profile Any -Protocol $definition.Protocol -LocalPort $definition.Port `
-Program $program -Service $service -RemoteAddress $ManagementAddresses | Out-Null
$firewallChanged = $true
$changes.Add("Firewall: $name")
}
if ($firewallChanged) { Save-NetGPO -GPOSession $session }
function Set-PolicyFile([string]$RelativePath, [string]$Content) {
$path = Join-Path $policyRoot $RelativePath
if ((Test-Path -LiteralPath $path) -and [IO.File]::ReadAllText($path) -eq $Content) { return $false }
New-Item -ItemType Directory -Path (Split-Path $path) -Force | Out-Null
[IO.File]::WriteAllText($path, $Content, [Text.UTF8Encoding]::new($false))
$changes.Add("File: $RelativePath")
return $true
}
$servicesXml = @'
<?xml version="1.0" encoding="utf-8"?>
<NTServices clsid="{2CFB484A-4E96-4b5d-A0B6-093D2F91E6AE}">
<NTService clsid="{AB6F0B67-341F-4e51-92F9-005FBFBA1A43}" name="WinRM" image="2" uid="{49771BD6-DA5C-4138-9C1A-E9CAAC7194F1}"><Properties startupType="AUTOMATIC" serviceName="WinRM" serviceAction="RESTART_IF_REQUIRED" timeout="30" /></NTService>
<NTService clsid="{AB6F0B67-341F-4e51-92F9-005FBFBA1A43}" name="TermService" image="2" uid="{05CF2CCF-006A-4829-92CD-9FF53867942E}"><Properties startupType="AUTOMATIC" serviceName="TermService" serviceAction="RESTART_IF_REQUIRED" timeout="30" /></NTService>
<NTService clsid="{AB6F0B67-341F-4e51-92F9-005FBFBA1A43}" name="RemoteRegistry" image="2" uid="{B09673B4-1054-4D2D-A29D-4203E2E7B60C}"><Properties startupType="MANUAL" serviceName="RemoteRegistry" serviceAction="NOCHANGE" timeout="30" /></NTService>
</NTServices>
'@
$fileChanged = Set-PolicyFile 'Machine\Preferences\Services\Services.xml' $servicesXml
$registryXml = @'
<?xml version="1.0" encoding="utf-8"?>
<RegistrySettings clsid="{A3CCFC41-DFDB-43a5-8D26-0FE8B954DA51}">
<Registry clsid="{9CD4B2F4-923D-47f5-A062-E897DD1DAD50}" name="fDenyTSConnections" status="fDenyTSConnections" image="2" uid="{65FCC5F4-38E4-4A55-A8E0-B41BF7F79CDD}"><Properties action="U" hive="HKEY_LOCAL_MACHINE" key="SYSTEM\CurrentControlSet\Control\Terminal Server" name="fDenyTSConnections" type="REG_DWORD" value="00000000" /></Registry>
<Registry clsid="{9CD4B2F4-923D-47f5-A062-E897DD1DAD50}" name="UserAuthentication" status="UserAuthentication" image="2" uid="{7F6126E4-534C-4AF6-8D9C-CB8642D1607C}"><Properties action="U" hive="HKEY_LOCAL_MACHINE" key="SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" name="UserAuthentication" type="REG_DWORD" value="00000001" /></Registry>
</RegistrySettings>
'@
$fileChanged = (Set-PolicyFile 'Machine\Preferences\Registry\Registry.xml' $registryXml) -or $fileChanged
$helperName = 'Enable-SguWorkstationRemoteAccess.ps1'
$helper = [IO.File]::ReadAllText((Join-Path $PSScriptRoot $helperName))
$fileChanged = (Set-PolicyFile "Machine\Scripts\Startup\$helperName" $helper) -or $fileChanged
$parameters = "-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"\\$dnsRoot\SYSVOL\$dnsRoot\Policies\{$($gpo.Id)}\Machine\Scripts\Startup\$helperName`""
if ($LocalDnsServer) {
[Net.IPAddress]::Parse($LocalDnsServer) | Out-Null
$parameters += " -LocalDnsServer $LocalDnsServer"
if ($FallbackDnsServer) {
[Net.IPAddress]::Parse($FallbackDnsServer) | Out-Null
$parameters += " -FallbackDnsServer $FallbackDnsServer"
}
} elseif ($FallbackDnsServer) {
throw 'FallbackDnsServer requires a LocalDnsServer.'
}
$scriptsIni = "[Startup]`r`n0CmdLine=powershell.exe`r`n0Parameters=$parameters`r`n"
$fileChanged = (Set-PolicyFile 'Machine\Scripts\scripts.ini' $scriptsIni) -or $fileChanged
$policy = Get-ADObject $policyDn -Server $DomainController -Properties gPCMachineExtensionNames,versionNumber
$extensions = [string]$policy.gPCMachineExtensionNames
foreach ($extension in @(
'[{B087BE9D-ED37-454F-AF9C-04291E351182}{BEE07A6A-EC9F-4659-B8C9-0B193F6C7FE2}]',
'[{91FBB303-0CD5-4055-BF42-E512A681B325}{CC5746A9-9B74-4BE5-AE2E-64379C86E0E4}]',
'[{42B5FAAE-6536-11D2-AE5A-0000F87571E3}{40B6664F-4972-11D1-A7CA-0000F87571E3}]'
)) {
if (-not $extensions.Contains($extension)) { $extensions += $extension; $fileChanged = $true }
}
if ($fileChanged) {
# Preserve the user-version word. Sort CSEs as required by Group Policy.
$extensions = (@([regex]::Matches($extensions, '\[[^\]]+\]') | ForEach-Object Value | Sort-Object -Unique) -join '')
$oldVersion = [long]$policy.versionNumber
$version = ($oldVersion -band 0xFFFF0000L) -bor (($oldVersion + 1) -band 0xFFFFL)
Set-ADObject $policyDn -Server $DomainController -Replace @{gPCMachineExtensionNames=$extensions; versionNumber=[int]$version}
[IO.File]::WriteAllText((Join-Path $policyRoot 'GPT.INI'), "[General]`r`nVersion=$version`r`n", [Text.UTF8Encoding]::new($false))
}
$links = @(Get-GPInheritance -Target $domainDn -Domain $dnsRoot -Server $DomainController).GpoLinks
$link = $links | Where-Object { $_.GpoId -eq $gpo.Id }
if (-not $link) {
New-GPLink -Guid $gpo.Id -Target $domainDn -Domain $dnsRoot -Server $DomainController -LinkEnabled Yes -Enforced Yes | Out-Null
$changes.Add('Linked at domain root')
} elseif (-not $link.Enabled -or -not $link.Enforced) {
Set-GPLink -Guid $gpo.Id -Target $domainDn -Domain $dnsRoot -Server $DomainController -LinkEnabled Yes -Enforced Yes | Out-Null
$changes.Add('Enabled enforced domain link')
}
[pscustomobject]@{Gpo=$GpoName; Id=[string]$gpo.Id; Domain=$dnsRoot; Changed=($changes.Count -gt 0); Changes=@($changes.ToArray())}
@@ -0,0 +1,100 @@
[CmdletBinding(SupportsShouldProcess)]
param(
[string]$TargetOuDn = 'OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$GpoName = 'SGU - Windows client experience',
[string]$DomainController = $env:COMPUTERNAME
)
$ErrorActionPreference = 'Stop'
$identity = [Security.Principal.WindowsIdentity]::GetCurrent()
if (-not ([Security.Principal.WindowsPrincipal]::new($identity)).IsInRole(
[Security.Principal.WindowsBuiltInRole]::Administrator)) {
throw 'Run this script elevated on the domain controller.'
}
Import-Module ActiveDirectory -ErrorAction Stop
Import-Module GroupPolicy -ErrorAction Stop
$targetOu = Get-ADOrganizationalUnit -Identity $TargetOuDn -Server $DomainController
$domain = Get-ADDomain -Server $DomainController
if (-not $targetOu.DistinguishedName.EndsWith($domain.DistinguishedName,
[StringComparison]::OrdinalIgnoreCase)) {
throw 'The target OU is outside the domain.'
}
$domainName = $domain.DNSRoot
$gpo = Get-GPO -Name $GpoName -Domain $domainName -Server $DomainController -ErrorAction Stop
$links = @(Get-GPInheritance -Target $TargetOuDn -Domain $domainName -Server $DomainController).GpoLinks
if (-not @($links | Where-Object { $_.DisplayName -eq $GpoName -and
[string]$_.Enabled -in @('True','Yes') }).Count) {
throw "The existing GPO '$GpoName' must be linked and enabled on $TargetOuDn."
}
# The existing machine GPO also manages the credential tile. These startup
# scripts are a native Group Policy extension, not scheduled client tasks.
$scriptNames = @(
'Enable-SguWorkstationRemoteAccess.ps1',
'Enable-SguWorkstationAdministrators.ps1'
)
$startupRoot = Join-Path $env:WINDIR "SYSVOL\domain\Policies\{$($gpo.Id)}\Machine\Scripts"
$scriptsIniPath = Join-Path $startupRoot 'scripts.ini'
$startupScripts = @(
foreach ($scriptName in $scriptNames) {
$sourcePath = Join-Path $PSScriptRoot $scriptName
$startupPath = Join-Path $startupRoot "Startup\$scriptName"
$source = [IO.File]::ReadAllText($sourcePath)
[pscustomobject]@{
Name = $scriptName
Path = $startupPath
Source = $source
Changed = -not (Test-Path -LiteralPath $startupPath) -or
[IO.File]::ReadAllText($startupPath) -cne $source
}
}
)
$iniLines = @('[Startup]')
for ($index = 0; $index -lt $scriptNames.Count; $index++) {
$unc = "\\$domainName\SYSVOL\$domainName\Policies\{$($gpo.Id)}\Machine\Scripts\Startup\$($scriptNames[$index])"
$iniLines += "${index}CmdLine=powershell.exe"
$iniLines += "${index}Parameters=-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$unc`""
}
$ini = ($iniLines -join "`r`n") + "`r`n"
$scriptChanged = @($startupScripts | Where-Object Changed).Count -gt 0
$iniChanged = -not (Test-Path -LiteralPath $scriptsIniPath) -or
[IO.File]::ReadAllText($scriptsIniPath) -cne $ini
if (($scriptChanged -or $iniChanged) -and
$PSCmdlet.ShouldProcess($startupRoot, 'Install computer startup script')) {
New-Item -ItemType Directory -Path (Join-Path $startupRoot 'Startup') -Force | Out-Null
foreach ($startupScript in $startupScripts) {
if ($startupScript.Changed) {
[IO.File]::WriteAllText($startupScript.Path, $startupScript.Source,
[Text.UTF8Encoding]::new($false))
}
}
[IO.File]::WriteAllText($scriptsIniPath, $ini, [Text.Encoding]::Unicode)
$gpoDn = "CN={$($gpo.Id)},CN=Policies,CN=System,$($domain.DistinguishedName)"
$adGpo = Get-ADObject -Identity $gpoDn -Server $DomainController `
-Properties gPCMachineExtensionNames,versionNumber
$extension = '[{42B5FAAE-6536-11D2-AE5A-0000F87571E3}{40B6664F-4972-11D1-A7CA-0000F87571E3}]'
$names = [string]$adGpo.gPCMachineExtensionNames
if ($names.IndexOf($extension, [StringComparison]::OrdinalIgnoreCase) -lt 0) {
Set-ADObject -Identity $gpoDn -Server $DomainController `
-Replace @{gPCMachineExtensionNames = "$names$extension"}
}
$gptPath = Join-Path (Split-Path (Split-Path $startupRoot -Parent) -Parent) 'GPT.ini'
$gpt = [IO.File]::ReadAllText($gptPath)
$gptVersion = [int]([regex]::Match($gpt, '(?m)^Version=(\d+)\r?$').Groups[1].Value)
$baseVersion = [Math]::Max($gptVersion, [int]$adGpo.versionNumber)
$nextVersion = ($baseVersion -band -65536) -bor (($baseVersion + 1) -band 65535)
[IO.File]::WriteAllText($gptPath,
[regex]::Replace($gpt, '(?m)^Version=\d+\r?$', "Version=$nextVersion"),
[Text.Encoding]::ASCII)
Set-ADObject -Identity $gpoDn -Server $DomainController -Replace @{versionNumber = $nextVersion}
}
[pscustomobject]@{
GpoName = $GpoName
GpoId = $gpo.Id
TargetOu = $TargetOuDn
StartupScripts = @($startupScripts.Path)
Changed = $scriptChanged -or $iniChanged
}
+45
View File
@@ -0,0 +1,45 @@
[CmdletBinding()]
param([switch]$InstallTask)
$ErrorActionPreference = 'Stop'
$directory = 'C:\ProgramData\LCI-Admin\CED-Client'
if ($InstallTask) {
New-Item $directory -ItemType Directory -Force | Out-Null
$acl = [Security.AccessControl.DirectorySecurity]::new()
$acl.SetAccessRuleProtection($true,$false)
foreach ($sid in 'S-1-5-18','S-1-5-32-544') {
$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new(
[Security.Principal.SecurityIdentifier]::new($sid),'FullControl','ContainerInherit,ObjectInherit','None','Allow'))
}
Set-Acl $directory $acl
$localScript = Join-Path $directory 'Invoke-SguCedClientEnrollment.ps1'
if ($PSCommandPath -ine $localScript) { Copy-Item $PSCommandPath $localScript -Force }
$action = New-ScheduledTaskAction -Execute powershell.exe -Argument ('-NoProfile -NonInteractive -ExecutionPolicy Bypass -File "{0}"' -f $localScript)
$triggers = @((New-ScheduledTaskTrigger -AtStartup),(New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(1) -RepetitionInterval (New-TimeSpan -Minutes 30)))
$settings = New-ScheduledTaskSettingsSet -StartWhenAvailable -MultipleInstances IgnoreNew -ExecutionTimeLimit (New-TimeSpan -Minutes 5)
Register-ScheduledTask 'CED Configuration Manager policy enrollment' -Action $action -Trigger $triggers -Settings $settings -User SYSTEM -RunLevel Highest -Force | Out-Null
Start-ScheduledTask 'CED Configuration Manager policy enrollment'
return
}
if (Get-Service CcmExec -ErrorAction SilentlyContinue) { return }
if (Get-Process ccmsetup -ErrorAction SilentlyContinue) { return }
# Check the machine's current OU with its own domain identity. An offline DC
# defers enrollment; an existing Wi-Fi connection continues using its cached PSK.
$root = [ADSI]'LDAP://RootDSE'
$search = [DirectoryServices.DirectorySearcher]::new([ADSI]("LDAP://"+[string]$root.defaultNamingContext))
try {
$search.Filter = '(&(objectClass=computer)(sAMAccountName='+$env:COMPUTERNAME+'$))'
[void]$search.PropertiesToLoad.Add('distinguishedName')
$result = $search.FindOne()
$dn = [string]$result.Properties['distinguishedname'][0]
$ou = 'OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx'
if (-not $dn.EndsWith(','+$ou,[StringComparison]::OrdinalIgnoreCase)) { return }
} finally { $search.Dispose() }
$source = '\\sgu-dc02.lci.lasalle.mx\CEDClient$'
$bootstrap = Join-Path $source 'ccmsetup.exe'
$signature = Get-AuthenticodeSignature $bootstrap
if ($signature.Status -ne 'Valid' -or $signature.SignerCertificate.Subject -notlike '*Microsoft Corporation*') {
throw 'Client bootstrapper is not a valid Microsoft-signed binary.'
}
Copy-Item $bootstrap (Join-Path $directory 'ccmsetup.exe') -Force
& (Join-Path $directory 'ccmsetup.exe') /service /source:$source SMSSITECODE=LCI SMSMP=sgu-dc02.lci.lasalle.mx
# ccmsetup/service runs asynchronously. Its own log and CcmExec verify completion.
+100
View File
@@ -0,0 +1,100 @@
[CmdletBinding()]
param(
[Parameter(Mandatory)][string]$InventoryPath,
[Parameter(Mandatory)][PSCredential]$Credential,
[string]$TargetOuDn = 'OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$DomainController = $env:COMPUTERNAME,
[string]$DnsServer = '192.168.54.211',
[string]$FallbackDnsServer = '192.168.54.1',
[switch]$InstallClient,
[switch]$MigrateWifi,
[switch]$RestartPendingInstall,
[string]$ClientSource = '\\sgu-dc02.lci.lasalle.mx\CEDClient$'
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
$domain = Get-ADDomain -Server $DomainController
Get-ADOrganizationalUnit -Identity $TargetOuDn -Server $DomainController | Out-Null
$allowed = @(Get-ADComputer -SearchBase $TargetOuDn -Filter 'Enabled -eq $true' -Server $DomainController)
$inventory = Get-Content -LiteralPath $InventoryPath -Raw | ConvertFrom-Json
$source = 'C:\Program Files\Microsoft Configuration Manager\Client\ccmsetup.exe'
if ($InstallClient) {
$signature = Get-AuthenticodeSignature -LiteralPath $source
if ($signature.Status -ne 'Valid' -or $signature.SignerCertificate.Subject -notlike '*Microsoft Corporation*') {
throw 'The Configuration Manager installer is not a valid Microsoft signed binary.'
}
}
$options = New-PSSessionOption -OpenTimeout 10000 -OperationTimeout 180000
foreach ($item in $inventory) {
if ($item.WinRM -eq $false) { continue }
if ($item.Name -notin $allowed.Name) { throw "Inventory host outside approved OU: $($item.Name)" }
[Net.IPAddress]::Parse($item.IP) | Out-Null
$session = $null
try {
$address = $item.IP
# After migration the old DHCP address is stale. Prefer a reachable
# current AD/DNS hostname, then validate the actual remote identity.
$hostname = ($allowed | Where-Object Name -eq $item.Name).DNSHostName
if (-not $hostname) { $hostname = $item.Name+'.'+$domain.DNSRoot }
$probe = [Net.Sockets.TcpClient]::new()
try {
$pending = $probe.BeginConnect($hostname,5985,$null,$null)
if ($pending.AsyncWaitHandle.WaitOne(1000) -and $probe.Connected) { $address = $hostname }
} catch { } finally { $probe.Dispose() }
$session = New-PSSession -ComputerName $address -Credential $Credential -Authentication Negotiate -SessionOption $options
$identity = Invoke-Command -Session $session {
[pscustomobject]@{Name=$env:COMPUTERNAME;Domain=(Get-CimInstance Win32_ComputerSystem).Domain;Trusted=Test-ComputerSecureChannel}
}
if ($identity.Name -ine $item.Name -or $identity.Domain -ine $domain.DNSRoot -or -not $identity.Trusted) {
throw 'Remote identity/domain/secure-channel validation failed.'
}
$state = Invoke-Command -Session $session -ArgumentList $DnsServer,$domain.DNSRoot,$FallbackDnsServer {
param($dns,$suffix,$fallbackDns)
New-Item C:\ProgramData\LCI-Admin -ItemType Directory -Force | Out-Null
$backup = 'C:\ProgramData\LCI-Admin\CED-dns-before.json'
if (-not (Test-Path $backup)) {
Get-DnsClientServerAddress -AddressFamily IPv4 | Select-Object InterfaceAlias,InterfaceIndex,ServerAddresses |
ConvertTo-Json -Depth 3 | Set-Content -LiteralPath $backup
}
$wifi = @(Get-NetAdapter | Where-Object { $_.NdisPhysicalMedium -eq 9 -and $_.Status -eq 'Up' })
if ($wifi.Count -ne 1) { throw 'Expected one active Wi-Fi interface.' }
Set-DnsClientServerAddress -InterfaceIndex $wifi[0].InterfaceIndex -ServerAddresses @($dns,$fallbackDns)
Set-DnsClient -InterfaceIndex $wifi[0].InterfaceIndex -ConnectionSpecificSuffix $suffix -RegisterThisConnectionsAddress $true
Register-DnsClient
& gpupdate.exe /target:computer /force /wait:90 | Out-Null
if ($LASTEXITCODE) { throw "gpupdate failed: $LASTEXITCODE" }
[pscustomobject]@{Name=$env:COMPUTERNAME;WifiPolicyPresent=(netsh.exe wlan show profiles | Select-String 'Centro de Experiencia Digital').Count -gt 0;ClientPresent=[bool](Get-Service CcmExec -ErrorAction SilentlyContinue)}
}
if (-not $state.WifiPolicyPresent) { throw 'Native CED Wi-Fi policy was not applied.' }
if ($InstallClient -and -not $state.ClientPresent) {
Copy-Item -LiteralPath $source -Destination C:\ProgramData\LCI-Admin\ccmsetup.exe -ToSession $session
Invoke-Command -Session $session -ArgumentList $ClientSource,[bool]$RestartPendingInstall {
param($clientSource,$restartPending)
if (-not $restartPending -and (Get-Process ccmsetup -ErrorAction SilentlyContinue)) { return }
# Replace a pending installer that was waiting for an inaccessible source.
if (Get-Service ccmsetup -ErrorAction SilentlyContinue) {
Stop-Service ccmsetup -Force -ErrorAction SilentlyContinue
}
# /source alone forces the complete SMB media. Combining it with
# /mp gives MP/DP discovery priority and can leave setup waiting.
$action = New-ScheduledTaskAction -Execute C:\ProgramData\LCI-Admin\ccmsetup.exe -Argument ('/source:"{0}" SMSSITECODE=LCI SMSMP=sgu-dc02.lci.lasalle.mx' -f $clientSource)
Register-ScheduledTask -TaskName 'CED Configuration Manager enrollment' -Action $action -User SYSTEM -RunLevel Highest -Force | Out-Null
Start-ScheduledTask -TaskName 'CED Configuration Manager enrollment'
}
}
if ($MigrateWifi) {
foreach ($file in 'Connect-SguCedWifi.ps1','Install-SguCedWifiMaintenance.ps1') {
Copy-Item (Join-Path $PSScriptRoot $file) (Join-Path C:\ProgramData\LCI-Admin $file) -ToSession $session -Force
}
Invoke-Command -Session $session {
& powershell.exe -NoProfile -ExecutionPolicy Bypass -File C:\ProgramData\LCI-Admin\Install-SguCedWifiMaintenance.ps1
if ($LASTEXITCODE) { throw 'Wi-Fi maintenance task installation failed.' }
}
}
[pscustomobject]@{Name=$item.Name;IP=$item.IP;Prepared=$true;ClientPresent=$state.ClientPresent;InstallationRequested=[bool]$InstallClient;Error=$null}
} catch {
[pscustomobject]@{Name=$item.Name;IP=$item.IP;Prepared=$false;ClientPresent=$false;InstallationRequested=$false;Error=$_.Exception.Message}
} finally {
if ($session) { Remove-PSSession $session }
}
}
+40 -3
View File
@@ -91,20 +91,22 @@ $clientRoot = Join-Path $resolvedOutputRoot "sgu-windows-client-bootstrap-$Versi
$serverRoot = Join-Path $resolvedOutputRoot "sgu-server-bootstrap-$Version" $serverRoot = Join-Path $resolvedOutputRoot "sgu-server-bootstrap-$Version"
$linuxClientRoot = Join-Path $resolvedOutputRoot "sgu-linux-client-bootstrap-$Version" $linuxClientRoot = Join-Path $resolvedOutputRoot "sgu-linux-client-bootstrap-$Version"
$azureRoot = Join-Path $resolvedOutputRoot "sgu-azure-infrastructure-$Version" $azureRoot = Join-Path $resolvedOutputRoot "sgu-azure-infrastructure-$Version"
$wifiRoot = Join-Path $resolvedOutputRoot "sgu-ced-wifi-policy-$Version"
$clientZip = "$clientRoot.zip" $clientZip = "$clientRoot.zip"
$serverZip = "$serverRoot.zip" $serverZip = "$serverRoot.zip"
$linuxClientZip = "$linuxClientRoot.zip" $linuxClientZip = "$linuxClientRoot.zip"
$azureZip = "$azureRoot.zip" $azureZip = "$azureRoot.zip"
$wifiZip = "$wifiRoot.zip"
foreach ($target in @( foreach ($target in @(
$clientRoot,$serverRoot,$linuxClientRoot,$azureRoot, $clientRoot,$serverRoot,$linuxClientRoot,$azureRoot,$wifiRoot,
$clientZip,$serverZip,$linuxClientZip,$azureZip)) { $clientZip,$serverZip,$linuxClientZip,$azureZip,$wifiZip)) {
if (Test-Path -LiteralPath $target) { if (Test-Path -LiteralPath $target) {
throw "Release target already exists: $target" throw "Release target already exists: $target"
} }
} }
New-Item -ItemType Directory ` New-Item -ItemType Directory `
-Path $clientRoot,$serverRoot,$linuxClientRoot,$azureRoot ` -Path $clientRoot,$serverRoot,$linuxClientRoot,$azureRoot,$wifiRoot `
-Force | Out-Null -Force | Out-Null
$welcomeFontNames = @( $welcomeFontNames = @(
'IndivisaTextSans-Regular.otf', 'IndivisaTextSans-Regular.otf',
@@ -206,13 +208,25 @@ Copy-RequiredFile -Source (Join-Path $PSScriptRoot 'Start-SguServerBootstrap.cmd
Copy-RequiredFile -Source (Join-Path $PSScriptRoot 'Start-SguAzureServerBootstrap.cmd') ` Copy-RequiredFile -Source (Join-Path $PSScriptRoot 'Start-SguAzureServerBootstrap.cmd') `
-Destination (Join-Path $serverRoot 'Start-SguAzureServerBootstrap.cmd') -Destination (Join-Path $serverRoot 'Start-SguAzureServerBootstrap.cmd')
$serverScripts = @( $serverScripts = @(
'Set-SguCedWifiPolicy.ps1',
'Install-SguCedWifiMaintenance.ps1',
'Repair-SguCedWifi.ps1',
'Sync-SguCedWifiReaders.ps1',
'Connect-SguCedWifi.ps1',
'Invoke-SguCedClientEnrollment.ps1',
'Deploy-AuthBroker.ps1', 'Deploy-AuthBroker.ps1',
'Disable-SguAzureUserRoaming.ps1', 'Disable-SguAzureUserRoaming.ps1',
'Enable-SguAzureUserRoaming.ps1', 'Enable-SguAzureUserRoaming.ps1',
'Enable-SguServerRemoteManagement.ps1', 'Enable-SguServerRemoteManagement.ps1',
'Enable-SguWorkstationRemoteAccess.ps1',
'Enable-SguWorkstationAdministrators.ps1',
'Get-SguUsageReport.ps1', 'Get-SguUsageReport.ps1',
'Get-SguBrokerLog.ps1', 'Get-SguBrokerLog.ps1',
'Install-SguDomainMonitoring.ps1', 'Install-SguDomainMonitoring.ps1',
'Install-SguWorkstationRemoteAccessPolicy.ps1',
'Install-SguDomainRemoteManagementPolicy.ps1',
'Sync-SguWacDomainConnections.ps1',
'Get-SguWorkstationRemoteManagementStatus.ps1',
'Publish-SguFsLogixClientDeployment.ps1', 'Publish-SguFsLogixClientDeployment.ps1',
'Install-SguRustDeskClient.ps1', 'Install-SguRustDeskClient.ps1',
'Install-SguRustDeskLinuxEnrollment.ps1', 'Install-SguRustDeskLinuxEnrollment.ps1',
@@ -224,6 +238,7 @@ $serverScripts = @(
'Register-SguClientCertificate.ps1', 'Register-SguClientCertificate.ps1',
'Register-SguRustDeskDevice.ps1', 'Register-SguRustDeskDevice.ps1',
'Set-LabBrokerDns.ps1', 'Set-LabBrokerDns.ps1',
'Set-SguInstitutionalPasswordPolicy.ps1',
'Set-SguDomainComputerPolicies.ps1', 'Set-SguDomainComputerPolicies.ps1',
'Set-SguLaboratorioWallpaperPolicy.ps1', 'Set-SguLaboratorioWallpaperPolicy.ps1',
'Set-SguLocalProfileSecurityPolicies.ps1', 'Set-SguLocalProfileSecurityPolicies.ps1',
@@ -291,11 +306,31 @@ Write-PackageManifest -PackageRoot $azureRoot -PackageVersion $Version -PackageK
Compress-Archive -Path (Join-Path $azureRoot '*') -DestinationPath $azureZip ` Compress-Archive -Path (Join-Path $azureRoot '*') -DestinationPath $azureZip `
-CompressionLevel Optimal -CompressionLevel Optimal
# Existing domains can publish the WLAN correction without running forest setup.
foreach ($scriptName in @(
'Set-SguCedWifiPolicy.ps1',
'Install-SguCedWifiMaintenance.ps1',
'Repair-SguCedWifi.ps1',
'Sync-SguCedWifiReaders.ps1',
'Connect-SguCedWifi.ps1',
'Invoke-SguCedClientEnrollment.ps1')) {
Copy-RequiredFile -Source (Join-Path $PSScriptRoot $scriptName) `
-Destination (Join-Path $wifiRoot $scriptName)
}
Copy-RequiredFile -Source (Join-Path $repositoryRoot 'docs\ced-wifi-release.md') `
-Destination (Join-Path $wifiRoot 'README.md')
Copy-RequiredFile -Source (Join-Path $repositoryRoot 'docs\ced-network-operations.md') `
-Destination (Join-Path $wifiRoot 'ced-network-operations.md')
Write-PackageManifest -PackageRoot $wifiRoot -PackageVersion $Version -PackageKind CedWifiPolicy
Compress-Archive -Path (Join-Path $wifiRoot '*') -DestinationPath $wifiZip `
-CompressionLevel Optimal
$checksums = @( $checksums = @(
("{0} {1}" -f (Get-FileHash -LiteralPath $clientZip -Algorithm SHA256).Hash, (Split-Path $clientZip -Leaf)) ("{0} {1}" -f (Get-FileHash -LiteralPath $clientZip -Algorithm SHA256).Hash, (Split-Path $clientZip -Leaf))
("{0} {1}" -f (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash, (Split-Path $serverZip -Leaf)) ("{0} {1}" -f (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash, (Split-Path $serverZip -Leaf))
("{0} {1}" -f (Get-FileHash -LiteralPath $linuxClientZip -Algorithm SHA256).Hash, (Split-Path $linuxClientZip -Leaf)) ("{0} {1}" -f (Get-FileHash -LiteralPath $linuxClientZip -Algorithm SHA256).Hash, (Split-Path $linuxClientZip -Leaf))
("{0} {1}" -f (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash, (Split-Path $azureZip -Leaf)) ("{0} {1}" -f (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash, (Split-Path $azureZip -Leaf))
("{0} {1}" -f (Get-FileHash -LiteralPath $wifiZip -Algorithm SHA256).Hash, (Split-Path $wifiZip -Leaf))
) )
$checksumsPath = Join-Path $resolvedOutputRoot "SHA256SUMS-$Version.txt" $checksumsPath = Join-Path $resolvedOutputRoot "SHA256SUMS-$Version.txt"
[IO.File]::WriteAllLines($checksumsPath, $checksums, [Text.UTF8Encoding]::new($false)) [IO.File]::WriteAllLines($checksumsPath, $checksums, [Text.UTF8Encoding]::new($false))
@@ -310,6 +345,8 @@ $checksumsPath = Join-Path $resolvedOutputRoot "SHA256SUMS-$Version.txt"
ServerSha256 = (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash ServerSha256 = (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash
AzureInfrastructurePackage = $azureZip AzureInfrastructurePackage = $azureZip
AzureInfrastructureSha256 = (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash AzureInfrastructureSha256 = (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash
CedWifiPolicyPackage = $wifiZip
CedWifiPolicySha256 = (Get-FileHash -LiteralPath $wifiZip -Algorithm SHA256).Hash
Checksums = $checksumsPath Checksums = $checksumsPath
RuntimeInstaller = $runtimeInstaller.Name RuntimeInstaller = $runtimeInstaller.Name
} }
+8 -1
View File
@@ -23,6 +23,7 @@ $assetPaths = @(
(Join-Path $ReleaseDirectory "sgu-server-bootstrap-$Version.zip"), (Join-Path $ReleaseDirectory "sgu-server-bootstrap-$Version.zip"),
(Join-Path $ReleaseDirectory "sgu-linux-client-bootstrap-$Version.zip"), (Join-Path $ReleaseDirectory "sgu-linux-client-bootstrap-$Version.zip"),
(Join-Path $ReleaseDirectory "sgu-azure-infrastructure-$Version.zip"), (Join-Path $ReleaseDirectory "sgu-azure-infrastructure-$Version.zip"),
(Join-Path $ReleaseDirectory "sgu-ced-wifi-policy-$Version.zip"),
(Join-Path $ReleaseDirectory "SHA256SUMS-$Version.txt") (Join-Path $ReleaseDirectory "SHA256SUMS-$Version.txt")
) )
foreach ($assetPath in $assetPaths) { foreach ($assetPath in $assetPaths) {
@@ -143,7 +144,8 @@ Las contraseñas se solicitan de forma interactiva y no se escriben en archivos
target_commitish = $TargetCommitish target_commitish = $TargetCommitish
name = "SGU Credential Provider $Version" name = "SGU Credential Provider $Version"
body = $releaseNotes body = $releaseNotes
draft = [bool]$Draft # Keep the release private until every attachment has uploaded.
draft = $true
prerelease = $Version -match '-' prerelease = $Version -match '-'
} }
@@ -175,6 +177,11 @@ Las contraseñas se solicitan de forma interactiva y no se escriben en archivos
} }
} }
if (-not $Draft) {
$release = Invoke-GiteaJson -Method ([Net.Http.HttpMethod]::Patch) `
-RelativeUri "$repositoryPath/releases/$($release.id)" -Body @{draft=$false}
}
[pscustomobject]@{ [pscustomobject]@{
Tag = $tagName Tag = $tagName
ReleaseName = $release.name ReleaseName = $release.name
+108
View File
@@ -0,0 +1,108 @@
[CmdletBinding()]
param([switch]$PreferCedNow,[string]$ProvisionXml='')
$ErrorActionPreference='Stop'
$computer=Get-CimInstance Win32_ComputerSystem
if(-not $computer.PartOfDomain -or $computer.DomainRole -ne 1 -or $env:COMPUTERNAME -notmatch '^(AF|SD|SI)-'){return}
$destination='C:\ProgramData\LCI-Admin\CED-WiFi'
if(-not ('Sgu.CedMachineWifi' -as [type])){
Add-Type -ReferencedAssemblies System.dll,System.Xml.dll -TypeDefinition @'
using System;
using System.Collections.Generic;
using System.Collections;
using System.Runtime.InteropServices;
using System.Text;
using System.Xml;
namespace Sgu {
public class CedWifiResult { public string Interface; public string Ssid; public string Profile; public bool MachineProfileReady; public bool GroupProfileRepaired; public bool MachineProfileCreated; public int OtherProfilesMadeManual; public bool ConnectionRequested; public uint QueryError; }
public static class CedMachineWifi {
[StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)] struct Connection { public int Mode; [MarshalAs(UnmanagedType.LPWStr)] public string Profile; public IntPtr Ssid; public IntPtr Bssids; public int BssType; public uint Flags; }
[StructLayout(LayoutKind.Sequential)] struct Session { public int Id; public IntPtr Name; public int State; }
[DllImport("wlanapi.dll")] static extern uint WlanOpenHandle(uint v,IntPtr r,out uint n,out IntPtr h);
[DllImport("wlanapi.dll")] static extern uint WlanEnumInterfaces(IntPtr h,IntPtr r,out IntPtr p);
[DllImport("wlanapi.dll")] static extern uint WlanGetProfileList(IntPtr h,ref Guid i,IntPtr r,out IntPtr p);
[DllImport("wlanapi.dll",CharSet=CharSet.Unicode)] static extern uint WlanGetProfile(IntPtr h,ref Guid i,string name,IntPtr r,out IntPtr xml,ref uint flags,out uint access);
[DllImport("wlanapi.dll",CharSet=CharSet.Unicode)] static extern uint WlanSetProfile(IntPtr h,ref Guid i,uint flags,string xml,string security,[MarshalAs(UnmanagedType.Bool)]bool overwrite,IntPtr r,out uint reason);
[DllImport("wlanapi.dll",CharSet=CharSet.Unicode)] static extern uint WlanSetProfilePosition(IntPtr h,ref Guid i,string name,uint position,IntPtr r);
[DllImport("wlanapi.dll")] static extern uint WlanQueryInterface(IntPtr h,ref Guid i,int opcode,IntPtr r,out uint size,out IntPtr data,out int type);
[DllImport("wlanapi.dll")] static extern uint WlanSetInterface(IntPtr h,ref Guid i,int opcode,uint size,ref int data,IntPtr r);
[DllImport("wlanapi.dll",CharSet=CharSet.Unicode)] static extern uint WlanConnect(IntPtr h,ref Guid i,ref Connection c,IntPtr r);
[DllImport("wlanapi.dll")] static extern uint WlanCloseHandle(IntPtr h,IntPtr r);
[DllImport("wlanapi.dll")] static extern void WlanFreeMemory(IntPtr p);
[DllImport("wtsapi32.dll",CharSet=CharSet.Unicode,SetLastError=true)] static extern bool WTSEnumerateSessions(IntPtr h,int reserved,int version,out IntPtr list,out int count);
[DllImport("wtsapi32.dll",CharSet=CharSet.Unicode)] static extern bool WTSQuerySessionInformation(IntPtr h,int id,int type,out IntPtr data,out int bytes);
[DllImport("wtsapi32.dll")] static extern void WTSFreeMemory(IntPtr p);
static void Check(uint e){if(e!=0)throw new System.ComponentModel.Win32Exception((int)e);}
static XmlDocument Read(IntPtr h,ref Guid id,string name,out uint flags){IntPtr p=IntPtr.Zero;uint access;flags=0;uint e=WlanGetProfile(h,ref id,name,IntPtr.Zero,out p,ref flags,out access);if(e!=0)return null;try{var x=new XmlDocument();x.LoadXml(Marshal.PtrToStringUni(p));return x;}finally{WlanFreeMemory(p);}}
static string Text(XmlDocument x,string name){XmlNode n=x.SelectSingleNode("//*[local-name()='"+name+"']");return n==null?"":n.InnerText;}
static bool Auto(XmlDocument x){bool changed=false;XmlElement root=x.DocumentElement;XmlNode mode=root.SelectSingleNode("*[local-name()='connectionMode']");if(mode==null)throw new InvalidOperationException("Missing connection mode.");if(mode.InnerText!="auto"){mode.InnerText="auto";changed=true;}XmlNode sw=root.SelectSingleNode("*[local-name()='autoSwitch']");if(sw==null){sw=x.CreateElement("autoSwitch",root.NamespaceURI);root.InsertAfter(sw,mode);changed=true;}if(sw.InnerText!="false"){sw.InnerText="false";changed=true;}return changed;}
static void Save(IntPtr h,ref Guid id,uint flags,XmlDocument x){uint reason;uint e=WlanSetProfile(h,ref id,flags,x.OuterXml,null,true,IntPtr.Zero,out reason);if(e!=0)throw new InvalidOperationException("Cannot save WLAN profile: "+e+", reason="+reason);}
static void Connected(IntPtr h,ref Guid id,CedWifiResult result){IntPtr p=IntPtr.Zero;uint size;int type;uint e=WlanQueryInterface(h,ref id,7,IntPtr.Zero,out size,out p,out type);result.QueryError=e;try{if(e==0&&size>=556){result.Profile=Marshal.PtrToStringUni(IntPtr.Add(p,8));int len=Marshal.ReadInt32(p,520);if(len>=0&&len<=32){byte[] ssid=new byte[len];Marshal.Copy(IntPtr.Add(p,524),ssid,0,len);result.Ssid=Encoding.UTF8.GetString(ssid);}}}finally{if(p!=IntPtr.Zero)WlanFreeMemory(p);}}
static void Connect(IntPtr h,ref Guid id,string name){Connection c=new Connection{Mode=0,Profile=name,BssType=1};Check(WlanConnect(h,ref id,ref c,IntPtr.Zero));}
public static int UserSessions(){IntPtr list=IntPtr.Zero;int count,result=0;if(!WTSEnumerateSessions(IntPtr.Zero,0,1,out list,out count))throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());try{int size=Marshal.SizeOf(typeof(Session));for(int i=0;i<count;i++){Session s=(Session)Marshal.PtrToStructure(IntPtr.Add(list,i*size),typeof(Session));IntPtr p=IntPtr.Zero;int bytes;try{if(WTSQuerySessionInformation(IntPtr.Zero,s.Id,5,out p,out bytes)&&bytes>2&&!String.IsNullOrEmpty(Marshal.PtrToStringUni(p)))result++;}finally{if(p!=IntPtr.Zero)WTSFreeMemory(p);}}}finally{WTSFreeMemory(list);}return result;}
public static CedWifiResult[] Ensure(string provision,bool prefer,bool rollback,string prior,IDictionary facts){
const string ssid="Centro de Experiencia Digital", backup="CED - Equipo";IntPtr h=IntPtr.Zero,list=IntPtr.Zero;uint v;var results=new List<CedWifiResult>();Check(WlanOpenHandle(2,IntPtr.Zero,out v,out h));
try{Check(WlanEnumInterfaces(h,IntPtr.Zero,out list));int count=Marshal.ReadInt32(list);for(int i=0;i<count;i++){Guid id=(Guid)Marshal.PtrToStructure(IntPtr.Add(list,8+i*532),typeof(Guid));var r=new CedWifiResult{Interface=id.ToString()};Connected(h,ref id,r);int interfaceState=Marshal.ReadInt32(list,8+i*532+528);if(r.QueryError==5&&interfaceState==1&&facts!=null&&facts.Contains(id.ToString())){string[] row=facts[id.ToString()] as string[];if(row!=null&&row.Length==2){r.Profile=row[0];r.Ssid=row[1];}}
if(rollback){if(!String.IsNullOrEmpty(prior))Connect(h,ref id,prior);results.Add(r);continue;}
IntPtr autoData=IntPtr.Zero;uint autoSize;int autoType;try{Check(WlanQueryInterface(h,ref id,1,IntPtr.Zero,out autoSize,out autoData,out autoType));if(Marshal.ReadInt32(autoData)==0){int enabled=1;Check(WlanSetInterface(h,ref id,1,4,ref enabled,IntPtr.Zero));}}finally{if(autoData!=IntPtr.Zero)WlanFreeMemory(autoData);}
uint gpFlags;XmlDocument gp=Read(h,ref id,ssid,out gpFlags);
if(gp!=null&&(gpFlags&2)==0){bool changed=Auto(gp);if(Text(gp,"protected")=="false")changed=true;if(changed){Save(h,ref id,gpFlags,gp);r.GroupProfileRepaired=true;gp=Read(h,ref id,ssid,out gpFlags);}}
uint flags;XmlDocument machine=Read(h,ref id,backup,out flags);
if(machine==null){XmlDocument source=null;if(!String.IsNullOrEmpty(provision)){source=new XmlDocument();source.LoadXml(provision);}else if(gp!=null)source=(XmlDocument)gp.CloneNode(true);
if(source!=null){if(Text(source,"authentication")!="WPA2PSK"&&Text(source,"authentication")!="WPA3SAE")throw new InvalidOperationException("Expected Personal Wi-Fi profile.");XmlNode ssidNode=source.SelectSingleNode("//*[local-name()='SSID']/*[local-name()='name']");if(ssidNode==null||ssidNode.InnerText!=ssid)throw new InvalidOperationException("Unexpected SSID.");source.DocumentElement.SelectSingleNode("*[local-name()='name']").InnerText=backup;Auto(source);Save(h,ref id,0,source);r.MachineProfileCreated=true;machine=Read(h,ref id,backup,out flags);}
}else if(Auto(machine)){Save(h,ref id,flags,machine);machine=Read(h,ref id,backup,out flags);}
r.MachineProfileReady=machine!=null&&(flags&2)==0&&Text(machine,"protected")=="true"&&Text(machine,"connectionMode")=="auto";
if(r.MachineProfileReady){IntPtr profiles=IntPtr.Zero;try{Check(WlanGetProfileList(h,ref id,IntPtr.Zero,out profiles));int n=Marshal.ReadInt32(profiles),gpCount=0,backupPosition=-1;for(int p=0;p<n;p++){IntPtr item=IntPtr.Add(profiles,8+p*516);string name=Marshal.PtrToStringUni(item);if((Marshal.ReadInt32(item,512)&1)!=0)gpCount++;if(name==backup)backupPosition=p;uint f;XmlDocument other=Read(h,ref id,name,out f);if(other==null||f!=0)continue;XmlNode sn=other.SelectSingleNode("//*[local-name()='SSID']/*[local-name()='name']");XmlNode mode=other.DocumentElement.SelectSingleNode("*[local-name()='connectionMode']");if(sn!=null&&sn.InnerText!=ssid&&mode!=null&&mode.InnerText=="auto"){mode.InnerText="manual";Save(h,ref id,f,other);r.OtherProfilesMadeManual++;}}if(backupPosition!=gpCount)Check(WlanSetProfilePosition(h,ref id,backup,(uint)gpCount,IntPtr.Zero));}finally{if(profiles!=IntPtr.Zero)WlanFreeMemory(profiles);}
if((prefer&&r.Ssid!=ssid)||(String.IsNullOrEmpty(r.Ssid)&&r.QueryError==5023)){Connect(h,ref id,backup);r.ConnectionRequested=true;}
}
results.Add(r);
}}finally{if(list!=IntPtr.Zero)WlanFreeMemory(list);WlanCloseHandle(h,IntPtr.Zero);}return results.ToArray();
}
}
}
'@
}
function Get-CedConnectionFacts {
$facts=@{};$events=@()
try{$events=@(Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-WLAN-AutoConfig/Operational';Id=8001,8003} -MaxEvents 64 -ErrorAction Stop)}catch{}
foreach($event in $events){
[xml]$xml=$event.ToXml();$data=$xml.Event.EventData.Data
$interface=[string]($data|Where-Object Name -eq InterfaceGuid).'#text'
if(-not $interface){continue};$key=([guid]$interface).ToString()
if($facts.ContainsKey($key)){continue}
if($event.Id -eq 8001){$facts[$key]=[string[]]@([string]($data|Where-Object Name -eq ProfileName).'#text',[string]($data|Where-Object Name -eq SSID).'#text')}else{$facts[$key]=[string[]]@('','')}
}
return ,$facts
}
$before=@([Sgu.CedMachineWifi]::Ensure($ProvisionXml,[bool]$PreferCedNow,$false,'',(Get-CedConnectionFacts)))
$ProvisionXml=$null
$requested=@($before|Where-Object ConnectionRequested).Count -gt 0
$rolledBack=$false
if($requested){
for($attempt=0;$attempt -lt 10;$attempt++){
Start-Sleep -Seconds 2
$state=@([Sgu.CedMachineWifi]::Ensure('',$false,$false,'',(Get-CedConnectionFacts)))
if($state.Ssid -contains 'Centro de Experiencia Digital'){break}
}
if($PreferCedNow -and $state.Ssid -notcontains 'Centro de Experiencia Digital'){
foreach($prior in $before|Where-Object Profile){[void][Sgu.CedMachineWifi]::Ensure('',$false,$true,$prior.Profile,(Get-CedConnectionFacts))}
$rolledBack=$true
}
}else{$state=$before}
foreach($r in $state){
$adapter=Get-NetAdapter|Where-Object{[guid]$_.InterfaceGuid -eq [guid]$r.Interface}
if(-not $adapter -or -not $r.Ssid){continue}
if($r.Ssid -eq 'Centro de Experiencia Digital'){
$desired=@('192.168.54.211','192.168.54.1')
$actual=@((Get-DnsClientServerAddress -InterfaceIndex $adapter.ifIndex -AddressFamily IPv4).ServerAddresses)
if(($actual -join ',') -ne ($desired -join ',')){Set-DnsClientServerAddress -InterfaceIndex $adapter.ifIndex -ServerAddresses $desired}
}else{
# Emergency Wi-Fi must obtain its own DNS; the internal domain NRPT stays intact.
$localKey='HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\'+([guid]$adapter.InterfaceGuid).ToString('B')
$manual=(Get-ItemProperty -LiteralPath $localKey -Name NameServer -ErrorAction SilentlyContinue).NameServer
if($manual){Set-DnsClientServerAddress -InterfaceIndex $adapter.ifIndex -ResetServerAddresses}
}
}
if($requested -and -not $rolledBack){Register-DnsClient -ErrorAction SilentlyContinue}
$result=[pscustomobject]@{Utc=[DateTime]::UtcNow.ToString('o');Computer=[string]$env:COMPUTERNAME;Identity=[string][Security.Principal.WindowsIdentity]::GetCurrent().Name;UserSessions=[Sgu.CedMachineWifi]::UserSessions();MachineProfileReady=(@($state|Where-Object MachineProfileReady).Count -gt 0);ConnectedToCed=($state.Ssid -contains 'Centro de Experiencia Digital');RolledBack=$rolledBack;Interfaces=@($state|Select-Object Interface,Ssid,Profile,MachineProfileReady,GroupProfileRepaired,MachineProfileCreated,OtherProfilesMadeManual,ConnectionRequested,QueryError);PeriodicPolling=$false}
if(Test-Path -LiteralPath $destination){$result|ConvertTo-Json -Depth 5|Set-Content -LiteralPath(Join-Path $destination 'machine-wifi-status.json') -Encoding UTF8}
$result
+42
View File
@@ -0,0 +1,42 @@
# Local elevated setup for the workgroup administration PC, LCI-77.
# Domain computers receive the existing CED DNS GPO instead.
[CmdletBinding()]
param(
[string]$InterfaceAlias = 'Wi-Fi',
[string]$BackupPath = 'C:\Users\alex\Documents\CED-Network-Private\LCI77-Sala-DNS-before.json'
)
$ErrorActionPreference = 'Stop'
if ($env:COMPUTERNAME -ne 'LCI-77') { throw 'This setup is only for LCI-77.' }
$client = Get-DnsClient -InterfaceAlias $InterfaceAlias
if (-not (Test-Path -LiteralPath $BackupPath)) {
$client | Select-Object InterfaceAlias, ConnectionSpecificSuffix |
ConvertTo-Json | Set-Content -LiteralPath $BackupPath -Encoding UTF8
}
$rules = @(Get-DnsClientNrptRule | Where-Object { $_.Namespace -contains '.lci.lasalle.mx' })
if ($rules.Count -gt 0 -and ($rules.Count -ne 1 -or $rules[0].NameServers -ne '192.168.54.211')) {
throw 'An existing domain DNS rule needs review; it was not overwritten.'
}
$globalBefore = Get-DnsClientGlobalSetting
$globalBackupPath = Join-Path (Split-Path $BackupPath) 'LCI77-DnsSearchList-before.json'
if (-not (Test-Path -LiteralPath $globalBackupPath)) {
$globalBefore | Select-Object SuffixSearchList | ConvertTo-Json |
Set-Content -LiteralPath $globalBackupPath -Encoding UTF8
}
# DHCP connection suffixes can disappear when changing SSIDs. The explicit
# search list is persistent and also preserves existing VPN/interface suffixes.
$suffixes = @('lci.lasalle.mx') + @($globalBefore.SuffixSearchList) +
@(Get-DnsClient | Select-Object -ExpandProperty ConnectionSpecificSuffix)
$suffixes = @($suffixes | Where-Object { $_ } | Select-Object -Unique)
Set-DnsClientGlobalSetting -SuffixSearchList $suffixes
Set-DnsClient -InterfaceAlias $InterfaceAlias -ConnectionSpecificSuffix 'lci.lasalle.mx'
if ($rules.Count -eq 0) {
Add-DnsClientNrptRule -Namespace '.lci.lasalle.mx' -NameServers '192.168.54.211' -Comment 'CED domain DNS for local administrator Wi-Fi'
}
Clear-DnsClientCache
[pscustomobject]@{
Computer = $env:COMPUTERNAME
Suffix = (Get-DnsClient -InterfaceAlias $InterfaceAlias).ConnectionSpecificSuffix
SearchList = (Get-DnsClientGlobalSetting).SuffixSearchList
SI04 = @([Net.Dns]::GetHostAddresses('SI-04') | ForEach-Object IPAddressToString)
SGUDC02 = @([Net.Dns]::GetHostAddresses('SGU-DC02') | ForEach-Object IPAddressToString)
}
+44
View File
@@ -0,0 +1,44 @@
[CmdletBinding()]
param(
[string]$SourcePath = 'C:\Program Files\Microsoft Configuration Manager\Client',
[string]$DestinationPath = 'C:\ProgramData\LCI-Admin\ClientSource',
[string]$ShareName = 'CEDClient$',
[string]$ReaderGroup = 'LCI\CED-WiFi-Equipos',
[string]$TargetOuDn = 'OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx'
)
$ErrorActionPreference = 'Stop'
foreach ($file in 'ccmsetup.exe','x64\client.msi') {
if (-not (Test-Path (Join-Path $SourcePath $file))) { throw "Missing client media: $file" }
}
if ((Get-AuthenticodeSignature (Join-Path $SourcePath 'ccmsetup.exe')).Status -ne 'Valid') {
throw 'Client bootstrapper signature is invalid.'
}
New-Item -ItemType Directory -Path $DestinationPath -Force | Out-Null
$acl = [Security.AccessControl.DirectorySecurity]::new()
$acl.SetAccessRuleProtection($true,$false)
foreach ($sid in 'S-1-5-18','S-1-5-32-544') {
$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new(
[Security.Principal.SecurityIdentifier]::new($sid),'FullControl','ContainerInherit,ObjectInherit','None','Allow'))
}
$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new(
$ReaderGroup,'ReadAndExecute','ContainerInherit,ObjectInherit','None','Allow'))
Import-Module ActiveDirectory
$domain = Get-ADDomain
$computers = @(Get-ADComputer -SearchBase $TargetOuDn -Filter 'Enabled -eq $true')
foreach ($computer in $computers) {
$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new(
$computer.SID,'ReadAndExecute','ContainerInherit,ObjectInherit','None','Allow'))
}
Set-Acl -LiteralPath $DestinationPath -AclObject $acl
& robocopy.exe $SourcePath $DestinationPath /E /COPY:DAT /DCOPY:DAT /R:1 /W:1 /NFL /NDL /NJH /NJS /NP | Out-Null
if ($LASTEXITCODE -ge 8) { throw "Client media copy failed: $LASTEXITCODE" }
$share = Get-SmbShare -Name $ShareName -ErrorAction SilentlyContinue
if ($share -and $share.Path -ne $DestinationPath) { throw 'Share already exists at a different path.' }
if (-not $share) {
New-SmbShare -Name $ShareName -Path $DestinationPath -ReadAccess $ReaderGroup -FullAccess 'BUILTIN\Administrators' -EncryptData $true | Out-Null
}
foreach ($computer in $computers) {
# Direct machine permissions avoid waiting for existing Kerberos group tickets.
Grant-SmbShareAccess -Name $ShareName -AccountName ($domain.NetBIOSName+'\'+$computer.SamAccountName) -AccessRight Read -Force | Out-Null
}
[pscustomobject]@{Source="\\$env:COMPUTERNAME\$ShareName";Readers=$ReaderGroup;MediaVersion=(Get-Item (Join-Path $DestinationPath 'ccmsetup.exe')).VersionInfo.FileVersion}
+31
View File
@@ -0,0 +1,31 @@
[CmdletBinding()]
param(
[string]$SiteCode = 'LCI',
[string]$CollectionId = 'LCI00014',
[string]$CollectionName = 'Centro de Experiencia Digital',
[string]$OuCanonicalName = 'LCI.LASALLE.MX/LABORATORIO/CENTRO DE EXPERIENCIA DIGITAL',
[string]$ConsoleModule = 'C:\Program Files (x86)\Microsoft Configuration Manager\AdminConsole\bin\ConfigurationManager.psd1'
)
$ErrorActionPreference = 'Stop'
if ($OuCanonicalName -match '["\r\n]') { throw 'Invalid OU canonical name.' }
Import-Module $ConsoleModule
Push-Location ($SiteCode+':\')
try {
$collection = Get-CMDeviceCollection -CollectionId $CollectionId
if (-not $collection) { throw 'Expected managed collection is missing.' }
$rules = @(Get-CMDeviceCollectionQueryMembershipRule -CollectionId $CollectionId)
if ($rules.Count -gt 1) { throw 'Review unexpected additional membership rules before changing this collection.' }
$query = 'select SMS_R_SYSTEM.ResourceID,SMS_R_SYSTEM.ResourceType,SMS_R_SYSTEM.Name,SMS_R_SYSTEM.SMSUniqueIdentifier,SMS_R_SYSTEM.ResourceDomainORWorkgroup,SMS_R_SYSTEM.Client from SMS_R_System where SMS_R_System.SystemOUName = "'+$OuCanonicalName+'"'
if (-not $rules.Count -or $rules[0].QueryExpression -cne $query) {
if ($rules.Count) { Remove-CMDeviceCollectionQueryMembershipRule -CollectionId $CollectionId -RuleName $rules[0].RuleName -Force }
Add-CMDeviceCollectionQueryMembershipRule -CollectionId $CollectionId -RuleName 'Centro de Experiencia Digital OU' -QueryExpression $query
}
if ($collection.Name -cne $CollectionName) {
Set-CMDeviceCollection -CollectionId $CollectionId -NewName $CollectionName -RefreshType Both
} else {
Set-CMDeviceCollection -CollectionId $CollectionId -RefreshType Both
}
Invoke-CMSystemDiscovery -SiteCode $SiteCode
Invoke-CMCollectionUpdate -CollectionId $CollectionId
[pscustomobject]@{CollectionId=$CollectionId;Name=$CollectionName;OU=$OuCanonicalName;Evaluation='Periodic and incremental'}
} finally { Pop-Location }
+29
View File
@@ -0,0 +1,29 @@
[CmdletBinding()]
param(
[string]$TargetOuDn = 'OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$GpoName = 'CED - DNS de dominio',
[string]$DnsServer = '192.168.54.211',
[string]$DomainController = $env:COMPUTERNAME
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
Import-Module GroupPolicy
$domain = Get-ADDomain -Server $DomainController
Get-ADOrganizationalUnit -Identity $TargetOuDn -Server $DomainController | Out-Null
$gpo = Get-GPO -Name $GpoName -Domain $domain.DNSRoot -Server $DomainController -ErrorAction SilentlyContinue
if (-not $gpo) { $gpo = New-GPO -Name $GpoName -Domain $domain.DNSRoot -Server $DomainController }
if ($gpo.GpoStatus -ne 'UserSettingsDisabled') { $gpo.GpoStatus = [Microsoft.GroupPolicy.GpoStatus]::UserSettingsDisabled }
$name = $domain.DNSRoot+'\'+$GpoName
$namespace = '.'+$domain.DNSRoot
$rules = @(Get-DnsClientNrptRule -GpoName $name -Server $DomainController)
$rule = @($rules | Where-Object { $_.Namespace -contains $namespace })
if ($rule.Count -gt 1) { throw 'Duplicate domain DNS policy rules.' }
if (-not $rule.Count) {
Add-DnsClientNrptRule -GpoName $name -Server $DomainController -Namespace $namespace -NameServers $DnsServer -DisplayName 'CED internal domain DNS' | Out-Null
} elseif ($rule[0].NameServers -ne $DnsServer) {
Set-DnsClientNrptRule -GpoName $name -Server $DomainController -Name $rule[0].Name -NameServers $DnsServer
}
$link = (Get-GPInheritance -Target $TargetOuDn -Domain $domain.DNSRoot -Server $DomainController).GpoLinks | Where-Object GpoId -eq $gpo.Id
if (-not $link) { New-GPLink -Guid $gpo.Id -Target $TargetOuDn -Domain $domain.DNSRoot -Server $DomainController -LinkEnabled Yes | Out-Null }
elseif (-not $link.Enabled) { Set-GPLink -Guid $gpo.Id -Target $TargetOuDn -Domain $domain.DNSRoot -Server $DomainController -LinkEnabled Yes | Out-Null }
[pscustomobject]@{Gpo=$GpoName;TargetOu=$TargetOuDn;Namespace=$namespace;NameServers=$DnsServer}
@@ -0,0 +1,31 @@
[CmdletBinding()]
param()
$ErrorActionPreference = 'Stop'
if ($env:COMPUTERNAME -ine 'SGU-DC02') {
throw 'Run this site-specific firewall configuration on SGU-DC02.'
}
$address = '192.168.54.211'
if (-not (Get-NetIPAddress -AddressFamily IPv4 -IPAddress $address -ErrorAction SilentlyContinue)) {
throw 'The CED management-point address is not assigned to this server.'
}
$listener = @(Get-NetTCPConnection -LocalPort 10123 -State Listen -ErrorAction SilentlyContinue)
if (-not $listener.Count) { throw 'The Configuration Manager notification listener is not running.' }
$program = Join-Path $env:windir 'System32\dllhost.exe'
foreach ($connection in $listener) {
if ((Get-Process -Id $connection.OwningProcess).Path -ine $program) {
throw 'TCP 10123 is owned by an unexpected process; inspect it before opening the firewall.'
}
}
$settings = @{
Name = 'CED-ConfigMgr-Notification-TCP'
Direction = 'Inbound'; Action = 'Allow'; Enabled = 'True'; Profile = 'Domain'
Protocol = 'TCP'; LocalPort = 10123; LocalAddress = $address
RemoteAddress = @('192.168.54.0/24','192.168.55.0/24'); Program = $program
Description = 'Allow CED and Sala Inmersiva clients to the Configuration Manager notification server; no public or guest-subnet access.'
}
if (Get-NetFirewallRule -Name $settings.Name -ErrorAction SilentlyContinue) {
Set-NetFirewallRule @settings
} else {
New-NetFirewallRule @settings -DisplayName 'CED - ConfigMgr client notification TCP 10123' | Out-Null
}
Get-NetFirewallRule -Name $settings.Name | Select-Object Name,Enabled,Action,Profile
+28
View File
@@ -0,0 +1,28 @@
# Administrative setup for workgroup clients that have no AD DNS suffix.
# This narrowly scoped authoritative zone answers only the bare server name;
# the normal lci.lasalle.mx zone continues to handle its FQDN.
[CmdletBinding()]
param()
$ErrorActionPreference = 'Stop'
Import-Module DnsServer
if ($env:COMPUTERNAME -ne 'SGU-DC02') { throw 'Run this setup on SGU-DC02.' }
$zone = 'sgu-dc02'
$address = '192.168.54.211'
$existingZone = Get-DnsServerZone | Where-Object ZoneName -eq $zone
if (-not $existingZone) {
Add-DnsServerPrimaryZone -Name $zone -ReplicationScope Domain -DynamicUpdate None
} elseif (-not $existingZone.IsDsIntegrated -or $existingZone.DynamicUpdate -ne 'None') {
throw 'Existing short-name zone needs review.'
}
$records = @(Get-DnsServerResourceRecord -ZoneName $zone -Name '@' |
Where-Object { $_.RecordType -notin @('SOA','NS') })
if ($records.Count -gt 0) {
if ($records.Count -ne 1 -or $records[0].RecordType -ne 'A' -or
$records[0].RecordData.IPv4Address.IPAddressToString -ne $address) {
throw 'Existing short-name record differs; refusing to overwrite it.'
}
} else {
Add-DnsServerResourceRecordA -ZoneName $zone -Name '@' -IPv4Address $address -TimeToLive ([TimeSpan]::FromMinutes(5))
}
Resolve-DnsName "$zone." -Server 127.0.0.1 -Type A -DnsOnly |
Select-Object Name,IPAddress
+42
View File
@@ -0,0 +1,42 @@
[CmdletBinding()]
param(
[string]$DomainController = $env:COMPUTERNAME,
[string]$TargetOuDn = 'OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$GpoName = 'CED - Confianza de administracion',
[string[]]$DnsNames = @('sgu-dc02.lci.lasalle.mx','sgu-dc02'),
[string]$ExportPath = 'C:\ProgramData\LCI-Admin\CED-WAC.cer'
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
Import-Module GroupPolicy
Import-Module 'C:\Program Files\WindowsAdminCenter\PowerShellModules\Microsoft.WindowsAdminCenter.Configuration\Microsoft.WindowsAdminCenter.Configuration.psm1'
$domain = Get-ADDomain -Server $DomainController
Get-ADOrganizationalUnit -Identity $TargetOuDn -Server $DomainController | Out-Null
$subject = 'CN=CED-WAC-SGU-DC02'
$cert = Get-ChildItem Cert:\LocalMachine\My | Where-Object { $_.Subject -eq $subject -and $_.HasPrivateKey -and $_.NotAfter -gt (Get-Date).AddMonths(3) } | Sort-Object NotAfter -Descending | Select-Object -First 1
if (-not $cert) {
$cert = New-SelfSignedCertificate -Type SSLServerAuthentication -Subject $subject -DnsName $DnsNames -CertStoreLocation Cert:\LocalMachine\My -Provider 'Microsoft RSA SChannel Cryptographic Provider' -KeyAlgorithm RSA -KeyLength 3072 -KeySpec KeyExchange -KeyExportPolicy NonExportable -HashAlgorithm SHA256 -NotAfter (Get-Date).AddYears(2) -FriendlyName 'CED Windows Admin Center HTTPS'
}
New-Item -ItemType Directory -Path (Split-Path $ExportPath -Parent) -Force | Out-Null
Export-Certificate -Cert $cert -FilePath $ExportPath -Force | Out-Null
Import-Certificate -FilePath $ExportPath -CertStoreLocation Cert:\LocalMachine\Root | Out-Null
$blob = Get-ItemPropertyValue -LiteralPath "HKLM:\SOFTWARE\Microsoft\SystemCertificates\Root\Certificates\$($cert.Thumbprint)" -Name Blob
$gpo = Get-GPO -Name $GpoName -Domain $domain.DNSRoot -Server $DomainController -ErrorAction SilentlyContinue
if (-not $gpo) { $gpo = New-GPO -Name $GpoName -Domain $domain.DNSRoot -Server $DomainController }
$gpo.GpoStatus = [Microsoft.GroupPolicy.GpoStatus]::UserSettingsDisabled
Set-GPRegistryValue -Guid $gpo.Id -Domain $domain.DNSRoot -Server $DomainController -Key "HKLM\Software\Policies\Microsoft\SystemCertificates\Root\Certificates\$($cert.Thumbprint)" -ValueName Blob -Type Binary -Value $blob | Out-Null
$links = (Get-GPInheritance -Target $TargetOuDn -Domain $domain.DNSRoot -Server $DomainController).GpoLinks
if ($gpo.Id -notin $links.GpoId) { New-GPLink -Guid $gpo.Id -Target $TargetOuDn -Domain $domain.DNSRoot -Server $DomainController | Out-Null }
$keyPath = Join-Path "$env:ProgramData\Microsoft\Crypto\RSA\MachineKeys" $cert.PrivateKey.CspKeyContainerInfo.UniqueKeyContainerName
$acl = Get-Acl -LiteralPath $keyPath
$sid = [Security.Principal.SecurityIdentifier]::new('S-1-5-20')
$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new($sid,'Read','Allow'))
Set-Acl -LiteralPath $keyPath -AclObject $acl
$settings = 'C:\Program Files\WindowsAdminCenter\Service\appsettings.json'
$old = (Get-Content -LiteralPath $settings -Raw | ConvertFrom-Json).Kestrel.Endpoints.WindowsAdminCenter.Certificate.Subject
if ($old -ne 'CED-WAC-SGU-DC02') {
Copy-Item -LiteralPath $settings -Destination (Join-Path (Split-Path $ExportPath -Parent) "WAC-before-CED-$((Get-Date).ToString('yyyyMMddHHmmss')).json")
Set-WACCertificateSubjectName -Thumbprint $cert.Thumbprint -Target FrontEnd
Restart-WACService
}
[pscustomobject]@{Gpo=$GpoName;TargetOu=$TargetOuDn;Thumbprint=$cert.Thumbprint;DnsNames=@($cert.DnsNameList.Unicode);Expires=$cert.NotAfter;PublicCertificate=$ExportPath;PreviousSubject=$old}
+155
View File
@@ -0,0 +1,155 @@
[CmdletBinding(DefaultParameterSetName='File')]
param(
[Parameter(Mandatory,ParameterSetName='File')][string]$ProfilePath,
[Parameter(Mandatory,ParameterSetName='Xml')][xml]$ProfileDocument,
[string]$TargetOuDn = 'OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$GpoName = 'CED - Wi-Fi de salas',
[string]$DomainController = $env:COMPUTERNAME,
[string]$ReaderGroup = 'CED-WiFi-Equipos'
)
$ErrorActionPreference = 'Stop'
foreach ($file in 'Install-SguCedWifiMaintenance.ps1','Connect-SguCedWifi.ps1','Repair-SguCedWifi.ps1','Invoke-SguCedClientEnrollment.ps1') {
if (-not (Test-Path (Join-Path $PSScriptRoot $file))) { throw "Deploy the complete script set; missing $file." }
}
Import-Module ActiveDirectory
Import-Module GroupPolicy
$domain = Get-ADDomain -Server $DomainController
$ou = Get-ADOrganizationalUnit -Identity $TargetOuDn -Server $DomainController
if ($ou.DistinguishedName -notlike "*,$($domain.DistinguishedName)") { throw 'OU is outside this domain.' }
[xml]$profile = if($PSCmdlet.ParameterSetName -eq 'Xml'){$ProfileDocument.Clone()}else{Get-Content -LiteralPath $ProfilePath -Raw}
$ns = [Xml.XmlNamespaceManager]::new($profile.NameTable)
$ns.AddNamespace('w', 'http://www.microsoft.com/networking/WLAN/profile/v1')
$ssid = $profile.SelectSingleNode('//w:SSID/w:name', $ns).InnerText
$auth = $profile.SelectSingleNode('//w:authEncryption/w:authentication', $ns).InnerText
if ($auth -notin 'WPA2PSK','WPA3SAE' -or $profile.SelectSingleNode('//w:authEncryption/w:encryption', $ns).InnerText -ne 'AES') {
throw 'Only WPA2/WPA3 Personal with AES is supported.'
}
if ($profile.SelectSingleNode('//w:sharedKey/w:protected', $ns).InnerText -ne 'false') {
throw 'Supply a privately stored export with key=clear. Never commit that XML.'
}
$keyLength = $profile.SelectSingleNode('//w:sharedKey/w:keyMaterial', $ns).InnerText.Length
$keyType = $profile.SelectSingleNode('//w:sharedKey/w:keyType', $ns).InnerText
if ($keyType -eq 'networkKey') {
if ($auth -ne 'WPA2PSK' -or $profile.SelectSingleNode('//w:sharedKey/w:keyMaterial', $ns).InnerText -notmatch '^[0-9A-Fa-f]{64}$') { throw 'Invalid WPA2 network key.' }
} elseif ($keyType -ne 'passPhrase' -or $keyLength -lt 8 -or $keyLength -gt 63) { throw 'Invalid passphrase length.' }
$profile.SelectSingleNode('/w:WLANProfile/w:name', $ns).InnerText = $ssid
$profile.SelectSingleNode('//w:connectionMode', $ns).InnerText = 'auto'
$switch=$profile.SelectSingleNode('/w:WLANProfile/w:autoSwitch',$ns)
if(-not $switch){$switch=$profile.CreateElement('autoSwitch',$profile.DocumentElement.NamespaceURI);[void]$profile.DocumentElement.InsertAfter($switch,$profile.SelectSingleNode('/w:WLANProfile/w:connectionMode',$ns))}
$switch.InnerText='false'
$group = Get-ADGroup -Filter "SamAccountName -eq '$ReaderGroup'" -Server $DomainController
if (-not $group) {
$group = New-ADGroup -Name $ReaderGroup -SamAccountName $ReaderGroup -GroupCategory Security -GroupScope Global -Path $TargetOuDn -Server $DomainController -PassThru
}
if (-not $group.DistinguishedName.EndsWith(",$TargetOuDn",[StringComparison]::OrdinalIgnoreCase)) { throw 'Reader group is outside the target OU.' }
$computers = @(Get-ADComputer -SearchBase $TargetOuDn -Filter 'Enabled -eq $true' -Server $DomainController | Where-Object Name -match '^(AF|SD|SI)-')
$members = @(Get-ADGroupMember $group -Server $DomainController)
$add = @($computers | Where-Object { $_.DistinguishedName -notin $members.DistinguishedName })
$remove = @($members | Where-Object { $_.DistinguishedName -notin $computers.DistinguishedName })
if ($add.Count) { Add-ADGroupMember $group -Members $add -Server $DomainController }
if ($remove.Count) { Remove-ADGroupMember $group -Members $remove -Server $DomainController -Confirm:$false }
$gpo = Get-GPO -Name $GpoName -Server $DomainController -Domain $domain.DNSRoot -ErrorAction SilentlyContinue
if (-not $gpo) { $gpo = New-GPO -Name $GpoName -Server $DomainController -Domain $domain.DNSRoot }
if ($gpo.GpoStatus -ne 'UserSettingsDisabled') { $gpo.GpoStatus = [Microsoft.GroupPolicy.GpoStatus]::UserSettingsDisabled }
$gpoDn = "CN={$($gpo.Id)},CN=Policies,CN=System,$($domain.DistinguishedName)"
$parent = "CN=Machine,$gpoDn"
foreach ($name in 'Microsoft','Windows','IEEE80211') {
$dn = "CN=$name,$parent"
if (-not (Get-ADObject -SearchBase $parent -SearchScope OneLevel -LDAPFilter "(cn=$name)" -Server $DomainController)) {
New-ADObject -Name $name -Type container -Path $parent -Server $DomainController
}
$parent = $dn
}
$policyDn = "CN=CED Wi-Fi,$parent"
$escapedName = [Security.SecurityElement]::Escape($ssid)
$policyXml = '<WLANPolicy xmlns="http://www.microsoft.com/networking/WLAN/policy/v1">' +
"<name>$escapedName</name><description>Wi-Fi administrado exclusivamente para la OU CED.</description>" +
'<globalFlags><enableAutoConfig>true</enableAutoConfig><showDeniedNetwork>false</showDeniedNetwork><allowEveryoneToCreateAllUserProfiles>true</allowEveryoneToCreateAllUserProfiles></globalFlags>' +
'<networkFilter><denyAllIBSS>true</denyAllIBSS><denyAllESS>false</denyAllESS></networkFilter>' +
'<profileList>' + $profile.DocumentElement.OuterXml + '</profileList></WLANPolicy>'
$policy = Get-ADObject -SearchBase $parent -SearchScope OneLevel -LDAPFilter '(cn=CED Wi-Fi)' -Server $DomainController -Properties ms-net-ieee-80211-GP-PolicyData
$changed = -not $policy -or $policy.'ms-net-ieee-80211-GP-PolicyData' -cne $policyXml -or $add.Count -gt 0 -or $remove.Count -gt 0
if (-not $policy) {
# The native WLAN CSE reads this AD object (MS-GPWL), not a startup-script profile.
New-ADObject -Name 'CED Wi-Fi' -Type ms-net-ieee-80211-GroupPolicy -Path $parent -Server $DomainController -OtherAttributes @{
'ms-net-ieee-80211-GP-PolicyGUID' = ([guid]::NewGuid()).ToString('B')
'description' = 'CED managed wireless profile. Contains a PSK; restricted computer read access.'
}
}
# Remove inherited read access BEFORE publishing/updating any existing PSK.
$entry = [DirectoryServices.DirectoryEntry]::new("LDAP://$DomainController/$policyDn")
try {
$security = $entry.ObjectSecurity
$beforeSecurity=$security.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)
$security.SetAccessRuleProtection($true, $false)
foreach ($rule in @($security.GetAccessRules($true,$false,[Security.Principal.SecurityIdentifier]))) { $security.RemoveAccessRuleSpecific($rule) }
$forestRoot = Get-ADDomain -Identity (Get-ADForest -Server $DomainController).RootDomain -Server $DomainController
$controller = Get-ADComputer -Identity ($DomainController.Split('.')[0]) -Server $DomainController
foreach ($sid in @('S-1-5-18', "$($domain.DomainSID)-512", "$($forestRoot.DomainSID)-519", $controller.SID.Value)) {
$security.AddAccessRule([DirectoryServices.ActiveDirectoryAccessRule]::new([Security.Principal.SecurityIdentifier]::new($sid),[DirectoryServices.ActiveDirectoryRights]::GenericAll,[Security.AccessControl.AccessControlType]::Allow))
}
$security.AddAccessRule([DirectoryServices.ActiveDirectoryAccessRule]::new($group.SID,[DirectoryServices.ActiveDirectoryRights]::GenericRead,[Security.AccessControl.AccessControlType]::Allow))
# Direct computer ACEs avoid needing a reboot to refresh machine group tokens.
foreach ($computer in $computers) {
$security.AddAccessRule([DirectoryServices.ActiveDirectoryAccessRule]::new($computer.SID,[DirectoryServices.ActiveDirectoryRights]::GenericRead,[Security.AccessControl.AccessControlType]::Allow))
}
if($beforeSecurity -ne $security.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)){$entry.ObjectSecurity = $security;$entry.CommitChanges()}
} finally { $entry.Dispose() }
if ($changed) { Set-ADObject $policyDn -Server $DomainController -Replace @{'ms-net-ieee-80211-GP-PolicyData'=$policyXml} }
$adGpo = Get-ADObject $gpoDn -Server $DomainController -Properties versionNumber,gPCMachineExtensionNames
$root = Join-Path $env:WINDIR "SYSVOL\domain\Policies\{$($gpo.Id)}"
$startup = Join-Path $root 'Machine\Scripts\Startup'
New-Item $startup -ItemType Directory -Force | Out-Null
foreach ($file in 'Install-SguCedWifiMaintenance.ps1','Connect-SguCedWifi.ps1','Repair-SguCedWifi.ps1','Invoke-SguCedClientEnrollment.ps1') {
$source = Join-Path $PSScriptRoot $file
$destination = Join-Path $startup $file
if (-not (Test-Path $destination) -or (Get-FileHash $source).Hash -ne (Get-FileHash $destination).Hash) {
Copy-Item $source $destination -Force
$changed = $true
}
}
$scriptPath = "\\$($domain.DNSRoot)\SYSVOL\$($domain.DNSRoot)\Policies\{$($gpo.Id)}\Machine\Scripts\Startup\Install-SguCedWifiMaintenance.ps1"
$clientScriptPath = $scriptPath.Replace('Install-SguCedWifiMaintenance.ps1','Invoke-SguCedClientEnrollment.ps1')
$ini = "[Startup]`r`n0CmdLine=powershell.exe`r`n0Parameters=-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$scriptPath`"`r`n1CmdLine=powershell.exe`r`n1Parameters=-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$clientScriptPath`" -InstallTask`r`n"
$iniPath = Join-Path $root 'Machine\Scripts\scripts.ini'
if (-not (Test-Path $iniPath) -or (Get-Content $iniPath -Raw) -cne $ini) {
[IO.File]::WriteAllText($iniPath,$ini,[Text.Encoding]::Unicode)
$changed = $true
}
$extension = '[{0ACDD40C-75AC-47AB-BAA0-BF6DE7E7FE63}{2DA6AA7F-8C88-4194-A558-0D36E7FD3E64}]'
$names = [string]$adGpo.gPCMachineExtensionNames
if ($names.IndexOf($extension, [StringComparison]::OrdinalIgnoreCase) -lt 0) { $names += $extension; $changed = $true }
$scriptsExtension = '[{42B5FAAE-6536-11D2-AE5A-0000F87571E3}{40B6664F-4972-11D1-A7CA-0000F87571E3}]'
if ($names.IndexOf($scriptsExtension, [StringComparison]::OrdinalIgnoreCase) -lt 0) { $names += $scriptsExtension; $changed = $true }
if ($changed) {
$names = ([regex]::Matches($names, '\[[^\]]+\]') | ForEach-Object Value | Sort-Object -Unique) -join ''
$v = ([long]$adGpo.versionNumber -band 0xFFFF0000L) -bor (([long]$adGpo.versionNumber + 1) -band 0xFFFFL)
Set-ADObject $gpoDn -Server $DomainController -Replace @{gPCMachineExtensionNames=$names;versionNumber=[int]$v}
[IO.File]::WriteAllText((Join-Path $root 'GPT.INI'), "[General]`r`nVersion=$v`r`n", [Text.Encoding]::ASCII)
}
$link = (Get-GPInheritance -Target $TargetOuDn -Domain $domain.DNSRoot -Server $DomainController).GpoLinks | Where-Object GpoId -eq $gpo.Id
if (-not $link) { New-GPLink -Guid $gpo.Id -Target $TargetOuDn -Domain $domain.DNSRoot -Server $DomainController -LinkEnabled Yes | Out-Null }
elseif (-not $link.Enabled) { Set-GPLink -Guid $gpo.Id -Target $TargetOuDn -Domain $domain.DNSRoot -Server $DomainController -LinkEnabled Yes | Out-Null }
$filterName='CED - Wi-Fi AF SD SI'
$query="SELECT * FROM Win32_ComputerSystem WHERE DomainRole = 1 AND (Name LIKE 'AF-%' OR Name LIKE 'SD-%' OR Name LIKE 'SI-%')"
$encodedQuery="1;3;10;$($query.Length);WQL;root\CIMv2;$query;"
$filter=@(Get-ADObject -SearchBase "CN=SOM,CN=WMIPolicy,CN=System,$($domain.DistinguishedName)" -LDAPFilter '(objectClass=msWMI-Som)' -Server $DomainController -Properties msWMI-Name,msWMI-ID,msWMI-Parm2|Where-Object {$_.'msWMI-Name' -eq $filterName})
if($filter.Count -gt 1){throw 'Duplicate CED wireless WMI filters.'}
if(-not $filter.Count){
$id=([guid]::NewGuid()).ToString('B').ToUpperInvariant();$timestamp=[DateTime]::UtcNow.ToString('yyyyMMddHHmmss.ffffff-000')
$created=New-ADObject -Name $id -Type msWMI-Som -Path "CN=SOM,CN=WMIPolicy,CN=System,$($domain.DistinguishedName)" -Server $DomainController -OtherAttributes @{'msWMI-Name'=$filterName;'msWMI-ID'=$id;'msWMI-Parm1'='Wi-Fi clients AF, SD and SI only; excludes APPS and all servers.';'msWMI-Parm2'=$encodedQuery;'msWMI-Author'='La Salle';'msWMI-CreationDate'=$timestamp;'msWMI-ChangeDate'=$timestamp} -PassThru
$filter=@(Get-ADObject -Identity $created.DistinguishedName -Server $DomainController -Properties msWMI-ID,msWMI-Parm2)
}elseif($filter[0].'msWMI-Parm2' -ne $encodedQuery){throw 'CED wireless WMI query differs; inspect before modifying.'}
$reference="[$($domain.DNSRoot);$($filter[0].'msWMI-ID');0]"
$current=Get-ADObject -Identity $gpoDn -Server $DomainController -Properties gPCWQLFilter
if($current.gPCWQLFilter -ne $reference){Set-ADObject -Identity $gpoDn -Server $DomainController -Replace @{gPCWQLFilter=$reference};$changed=$true}
foreach($setting in @(
@{Key='HKLM\Software\Policies\Microsoft\Windows\System';Name='DontDisplayNetworkSelectionUI';Value=0},
@{Key='HKLM\Software\Policies\Microsoft\Windows\WcmSvc\GroupPolicy';Name='fBlockNonDomain';Value=0},
@{Key='HKLM\SYSTEM\CurrentControlSet\Services\WlanSvc';Name='Start';Value=2},
@{Key='HKLM\Software\Policies\LaSalle\CEDWifi';Name='ConfigurationVersion';Value=2}
)){
$old=Get-GPRegistryValue -Guid $gpo.Id -Server $DomainController -Key $setting.Key -ValueName $setting.Name -ErrorAction SilentlyContinue
if(-not $old -or [string]$old.Value -ne [string]$setting.Value){Set-GPRegistryValue -Guid $gpo.Id -Server $DomainController -Key $setting.Key -ValueName $setting.Name -Type DWord -Value $setting.Value|Out-Null;$changed=$true}
}
[pscustomobject]@{Gpo=$GpoName;Id=$gpo.Id;SSID=$ssid;TargetOu=$TargetOuDn;Computers=$computers.Count;ReaderGroup=$ReaderGroup;Changed=$changed}
@@ -0,0 +1,136 @@
[CmdletBinding(SupportsShouldProcess)]
param(
[string]$DomainController = $env:COMPUTERNAME,
[string]$BaseDn = 'DC=lci,DC=lasalle,DC=mx',
[string]$PolicyName = 'SGU - Institutional password authority',
[int]$Precedence = 100
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory -ErrorAction Stop
$domain = Get-ADDomain -Server $DomainController -ErrorAction Stop
if ($domain.DistinguishedName -ne $BaseDn) {
throw "BaseDn does not match the domain served by $DomainController."
}
if ($domain.DomainMode -lt 'Windows2012Domain') {
throw 'Fine-grained password policies require Windows Server 2012 domain functional level or newer.'
}
# AD's default password policy must remain intact for non-SGU accounts.
# The broker validates the exact password with SGU before resetting the AD
# verifier. These global security groups are assigned before SetPassword.
$groups = @(
"CN=SGU-Alumnos,OU=Alumnos,OU=Usuarios-SGU,$BaseDn",
"CN=SGU-Administrativos,OU=Administrativos,OU=Usuarios-SGU,$BaseDn",
"CN=SGU-Docentes,OU=Docentes,OU=Usuarios-SGU,$BaseDn"
)
foreach ($groupDn in $groups) {
$group = Get-ADGroup -Identity $groupDn -Server $DomainController -ErrorAction Stop
if ($group.GroupCategory -ne 'Security' -or $group.GroupScope -ne 'Global') {
throw "The password-policy subject must be a global security group: $groupDn"
}
}
$desired = @{
Precedence = $Precedence
ComplexityEnabled = $false
ReversibleEncryptionEnabled = $false
MinPasswordLength = 1
PasswordHistoryCount = 0
MinPasswordAge = [TimeSpan]::Zero
MaxPasswordAge = [TimeSpan]::Zero
LockoutThreshold = 0
LockoutDuration = [TimeSpan]::FromMinutes(10)
LockoutObservationWindow = [TimeSpan]::FromMinutes(10)
}
$policy = Get-ADFineGrainedPasswordPolicy -Filter * -Server $DomainController |
Where-Object { $_.Name -eq $PolicyName } |
Select-Object -First 1
if (-not $policy) {
if ($PSCmdlet.ShouldProcess($PolicyName, 'Create password policy limited to SGU role groups')) {
New-ADFineGrainedPasswordPolicy -Name $PolicyName @desired -Server $DomainController `
-Description 'SGU validates the exact institutional password; reversible storage remains disabled and AD must not reject its complexity, length, history, or age.' `
-ProtectedFromAccidentalDeletion $true | Out-Null
}
}
else {
$different = @($desired.Keys | Where-Object { $policy.$_ -ne $desired[$_] })
if ($different.Count -gt 0 -and
$PSCmdlet.ShouldProcess($PolicyName, "Restore managed settings: $($different -join ', ')")) {
Set-ADFineGrainedPasswordPolicy -Identity $policy @desired -Server $DomainController | Out-Null
}
}
$policy = Get-ADFineGrainedPasswordPolicy -Filter * -Properties AppliesTo `
-Server $DomainController |
Where-Object { $_.Name -eq $PolicyName } |
Select-Object -First 1
if (-not $policy) {
if ($WhatIfPreference) { return }
throw "The fine-grained policy $PolicyName was not created."
}
foreach ($groupDn in $groups) {
if (@($policy.AppliesTo) -notcontains $groupDn) {
if ($PSCmdlet.ShouldProcess($groupDn, "Apply $PolicyName")) {
Add-ADFineGrainedPasswordPolicySubject -Identity $policy -Subjects $groupDn `
-Server $DomainController -ErrorAction Stop
}
}
}
# Existing SGU group members must have the per-account UAC bit cleared as well.
# The default domain policy stays unchanged, and users outside these three SGU
# groups are deliberately excluded.
$reversibleAccountsDisabled = 0
$usersOuDn = "OU=Usuarios-SGU,$BaseDn"
$managedUserDns = [Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
foreach ($groupDn in $groups) {
foreach ($member in Get-ADGroupMember -Identity $groupDn -Recursive `
-Server $DomainController -ErrorAction Stop) {
if ($member.objectClass -eq 'user') {
[void]$managedUserDns.Add($member.DistinguishedName)
}
}
}
foreach ($userDn in $managedUserDns) {
$user = Get-ADUser -Identity $userDn -Properties AllowReversiblePasswordEncryption `
-Server $DomainController -ErrorAction Stop
if (-not $user.DistinguishedName.EndsWith(",$usersOuDn", [StringComparison]::OrdinalIgnoreCase)) {
continue
}
if ($user.AllowReversiblePasswordEncryption -and
$PSCmdlet.ShouldProcess($user.SamAccountName, 'Disable reversible password storage for SGU account')) {
Set-ADAccountControl -Identity $user.DistinguishedName `
-AllowReversiblePasswordEncryption $false -Server $DomainController -Confirm:$false
$reversibleAccountsDisabled++
}
}
$policy = Get-ADFineGrainedPasswordPolicy -Identity $PolicyName -Properties AppliesTo `
-Server $DomainController -ErrorAction Stop
if (-not $WhatIfPreference) {
foreach ($key in $desired.Keys) {
if ($policy.$key -ne $desired[$key]) {
throw "Password policy setting $key did not match the expected value."
}
}
foreach ($groupDn in $groups) {
if (@($policy.AppliesTo) -notcontains $groupDn) {
throw "Password policy is not applied to $groupDn."
}
}
}
[pscustomobject]@{
Name = $policy.Name
Precedence = $policy.Precedence
ComplexityEnabled = $policy.ComplexityEnabled
ReversibleEncryptionEnabled = $policy.ReversibleEncryptionEnabled
MinPasswordLength = $policy.MinPasswordLength
PasswordHistoryCount = $policy.PasswordHistoryCount
MaxPasswordAge = $policy.MaxPasswordAge
ExistingAccountFlagsDisabled = $reversibleAccountsDisabled
Subjects = @($policy.AppliesTo)
}
+82
View File
@@ -0,0 +1,82 @@
[CmdletBinding()]
param(
[string]$TargetOuDn = 'OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$DomainController = $env:COMPUTERNAME,
[string]$GpoName = 'CED - Wi-Fi de salas',
[string]$ReaderGroup = 'CED-WiFi-Equipos',
[switch]$InstallRefreshTask
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
Import-Module GroupPolicy
$domain = Get-ADDomain -Server $DomainController
Get-ADOrganizationalUnit -Identity $TargetOuDn -Server $DomainController | Out-Null
$group = Get-ADGroup $ReaderGroup -Server $DomainController
if (-not $group.DistinguishedName.EndsWith(",$TargetOuDn",[StringComparison]::OrdinalIgnoreCase)) { throw 'Reader group is outside the target OU.' }
$gpo = Get-GPO -Name $GpoName -Server $DomainController -Domain $domain.DNSRoot
$gpoDn = "CN={$($gpo.Id)},CN=Policies,CN=System,$($domain.DistinguishedName)"
$policyDn = "CN=CED Wi-Fi,CN=IEEE80211,CN=Windows,CN=Microsoft,CN=Machine,$gpoDn"
if ($InstallRefreshTask) {
# SYSTEM authenticates to AD as this DC. Delegate only these specific
# properties; no domain administrator password is stored in a task.
$controllerSid = (Get-ADComputer ($DomainController.Split('.')[0]) -Server $DomainController).SID
$schemaDn = (Get-ADRootDSE -Server $DomainController).schemaNamingContext
foreach ($target in @(@{Dn=$group.DistinguishedName;Attribute='member'},@{Dn=$gpoDn;Attribute='versionNumber'})) {
$attribute = Get-ADObject -SearchBase $schemaDn -LDAPFilter "(lDAPDisplayName=$($target.Attribute))" -Server $DomainController -Properties schemaIDGUID
$entry = [DirectoryServices.DirectoryEntry]::new("LDAP://$DomainController/$($target.Dn)")
try {
$acl = $entry.ObjectSecurity
$acl.AddAccessRule([DirectoryServices.ActiveDirectoryAccessRule]::new($controllerSid,[DirectoryServices.ActiveDirectoryRights]::WriteProperty,[Security.AccessControl.AccessControlType]::Allow,[guid]::new([byte[]]$attribute.schemaIDGUID)))
$entry.ObjectSecurity=$acl; $entry.CommitChanges()
} finally { $entry.Dispose() }
}
$taskDirectory = 'C:\ProgramData\LCI-Admin\CED-WiFi-Readers'
New-Item $taskDirectory -ItemType Directory -Force | Out-Null
$fileAcl = [Security.AccessControl.DirectorySecurity]::new()
$fileAcl.SetAccessRuleProtection($true,$false)
foreach ($sid in 'S-1-5-18','S-1-5-32-544') {
$fileAcl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new(
[Security.Principal.SecurityIdentifier]::new($sid),'FullControl','ContainerInherit,ObjectInherit','None','Allow'))
}
Set-Acl $taskDirectory $fileAcl
$taskScript = Join-Path $taskDirectory 'Sync-SguCedWifiReaders.ps1'
if ($PSCommandPath -ine $taskScript) { Copy-Item $PSCommandPath $taskScript -Force }
foreach ($value in $TargetOuDn,$DomainController,$GpoName,$ReaderGroup) {
if ($value.Contains('"')) { throw 'Task parameter contains an unsupported quote.' }
}
$arguments = '-NoProfile -NonInteractive -ExecutionPolicy Bypass -File "{0}" -TargetOuDn "{1}" -DomainController "{2}" -GpoName "{3}" -ReaderGroup "{4}"' -f $taskScript,$TargetOuDn,$DomainController,$GpoName,$ReaderGroup
$action = New-ScheduledTaskAction -Execute powershell.exe -Argument $arguments
$trigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(1) -RepetitionInterval (New-TimeSpan -Minutes 15)
Register-ScheduledTask -TaskName 'CED WiFi OU readers refresh' -Action $action -Trigger $trigger -User SYSTEM -RunLevel Highest -Force | Out-Null
}
$computers = @(Get-ADComputer -SearchBase $TargetOuDn -Filter 'Enabled -eq $true' -Server $DomainController | Where-Object Name -match '^(AF|SD|SI)-')
$members = @(Get-ADGroupMember $group -Server $DomainController)
$add = @($computers | Where-Object DistinguishedName -notin $members.DistinguishedName)
$remove = @($members | Where-Object DistinguishedName -notin $computers.DistinguishedName)
if ($add.Count) { Add-ADGroupMember $group -Members $add -Server $DomainController }
if ($remove.Count) { Remove-ADGroupMember $group -Members $remove -Server $DomainController -Confirm:$false }
$changed = $add.Count -gt 0 -or $remove.Count -gt 0
$entry = [DirectoryServices.DirectoryEntry]::new("LDAP://$DomainController/$policyDn")
try {
$acl = $entry.ObjectSecurity
$rules = @($acl.GetAccessRules($true,$false,[Security.Principal.SecurityIdentifier]))
foreach ($rule in $rules) {
if ($rule.ActiveDirectoryRights -eq [DirectoryServices.ActiveDirectoryRights]::GenericRead -and
$rule.IdentityReference.Value -ne $group.SID.Value -and $rule.IdentityReference.Value -notin $computers.SID.Value) {
$acl.RemoveAccessRuleSpecific($rule); $changed=$true
}
}
foreach ($computer in $computers) {
if ($computer.SID.Value -notin $rules.IdentityReference.Value) {
$acl.AddAccessRule([DirectoryServices.ActiveDirectoryAccessRule]::new($computer.SID,[DirectoryServices.ActiveDirectoryRights]::GenericRead,[Security.AccessControl.AccessControlType]::Allow));$changed=$true
}
}
if ($changed) { $entry.ObjectSecurity=$acl; $entry.CommitChanges() }
} finally { $entry.Dispose() }
if ($changed) {
$adGpo=Get-ADObject $gpoDn -Server $DomainController -Properties versionNumber
$version=([long]$adGpo.versionNumber -band 0xFFFF0000L) -bor (([long]$adGpo.versionNumber+1) -band 0xFFFFL)
Set-ADObject $gpoDn -Server $DomainController -Replace @{versionNumber=[int]$version}
[IO.File]::WriteAllText("$env:WINDIR\SYSVOL\domain\Policies\{$($gpo.Id)}\GPT.INI","[General]`r`nVersion=$version`r`n",[Text.Encoding]::ASCII)
}
[pscustomobject]@{TargetOu=$TargetOuDn;Computers=$computers.Count;Added=$add.Count;Removed=$remove.Count;Changed=$changed}
+58
View File
@@ -0,0 +1,58 @@
# Keep bare-name DNS answers available to Sala workgroup clients with no suffix.
# Each narrowly scoped zone has one A record; normal FQDN records remain the
# source of truth. No root zone, wildcard, nonsecure updates, or hosts-file edits.
[CmdletBinding()]
param([string]$ManifestPath = 'C:\ProgramData\LCI-Admin\Sala-DNS\manifest.json')
$ErrorActionPreference = 'Stop'
Import-Module DnsServer
if ($env:COMPUTERNAME -ne 'SGU-DC02') { throw 'Run this sync on SGU-DC02.' }
$folder = Split-Path $ManifestPath
$statePath = Join-Path $folder 'short-names-owned.json'
$manifest = Get-Content -LiteralPath $ManifestPath -Raw | ConvertFrom-Json
if ($manifest.Zone -ne 'lci.lasalle.mx') { throw 'Unexpected source zone.' }
$owned = @{}
if (Test-Path -LiteralPath $statePath) {
$state = Get-Content -LiteralPath $statePath -Raw | ConvertFrom-Json
foreach ($property in $state.PSObject.Properties) { $owned[$property.Name] = $property.Value }
}
$results = @()
$failed = $false
foreach ($name in (@('sgu-dc02') + @($manifest.Records.Name) | Sort-Object -Unique)) {
try {
if ($name -notmatch '^(sgu-dc02|si-\d{2})$') { throw 'Name outside approved scope.' }
$source = @(Get-DnsServerResourceRecord -ZoneName $manifest.Zone -Name $name -RRType A)
if ($source.Count -ne 1) { throw 'Expected one source A record.' }
$ip = $source[0].RecordData.IPv4Address.IPAddressToString
if ($ip -notmatch '^192\.168\.(54|55)\.\d{1,3}$') { throw 'Source IP outside managed networks.' }
$zone = Get-DnsServerZone | Where-Object ZoneName -eq $name
if (-not $zone) {
Add-DnsServerPrimaryZone -Name $name -ReplicationScope Domain -DynamicUpdate None
$owned[$name] = $ip
} elseif (-not $owned.ContainsKey($name) -or -not $zone.IsDsIntegrated -or $zone.DynamicUpdate -ne 'None') {
throw 'Existing bare-name zone is not owned by this sync.'
}
$records = @(Get-DnsServerResourceRecord -ZoneName $name -Name '@' | Where-Object RecordType -notin @('SOA','NS'))
if ($records.Count -eq 0) {
Add-DnsServerResourceRecordA -ZoneName $name -Name '@' -IPv4Address $ip -TimeToLive ([TimeSpan]::FromMinutes(5))
} elseif ($records.Count -ne 1 -or $records[0].RecordType -ne 'A' -or
$records[0].RecordData.IPv4Address.IPAddressToString -ne $owned[$name]) {
throw 'Bare-name record differs from the owned record; refusing to overwrite it.'
} elseif ($ip -ne $owned[$name]) {
$updated = $records[0].Clone()
$updated.RecordData.IPv4Address = [Net.IPAddress]::Parse($ip)
$updated.TimeToLive = [TimeSpan]::FromMinutes(5)
Set-DnsServerResourceRecord -ZoneName $name -OldInputObject $records[0] -NewInputObject $updated
}
$owned[$name] = $ip
$results += [pscustomobject]@{Name=$name;IP=$ip;Status='Current';Error=$null}
} catch {
$failed = $true
$results += [pscustomobject]@{Name=$name;IP=$null;Status='Error';Error=$_.Exception.Message}
}
}
$owned | ConvertTo-Json | Set-Content -LiteralPath "$statePath.next" -Encoding UTF8
Move-Item -LiteralPath "$statePath.next" -Destination $statePath -Force
[pscustomobject]@{Time=(Get-Date).ToString('o');Records=$results} | ConvertTo-Json -Depth 5 |
Set-Content -LiteralPath (Join-Path $folder 'short-names-result.json') -Encoding UTF8
$results
if ($failed) { throw 'Some bare-name records could not be synchronized. See short-names-result.json.' }
+72
View File
@@ -0,0 +1,72 @@
# Run locally on SGU-DC02 as SYSTEM. The protected manifest owns only explicitly
# approved workgroup names; never import arbitrary router clients into AD DNS.
[CmdletBinding()]
param(
[string]$ManifestPath = 'C:\ProgramData\LCI-Admin\Sala-DNS\manifest.json'
)
$ErrorActionPreference = 'Stop'
Import-Module DnsServer
Import-Module ActiveDirectory
if ($env:COMPUTERNAME -ne 'SGU-DC02') { throw 'Run this sync on SGU-DC02.' }
$manifest = Get-Content -LiteralPath $ManifestPath -Raw | ConvertFrom-Json
if ($manifest.Zone -ne 'lci.lasalle.mx' -or $manifest.RouterDns -ne '192.168.55.1') {
throw 'Unexpected DNS zone or router in the manifest.'
}
$results = @()
$failed = $false
foreach ($entry in $manifest.Records) {
$result = [ordered]@{ Name = $entry.Name; Status = ''; IP = $null; Error = $null }
try {
if ($entry.Name -notmatch '^si-\d{2}$') { throw 'Name is outside the approved SI naming pattern.' }
# After domain enrollment, leave DNS management to the machine's secure
# registration. Do not fight a domain client or overwrite someone else's A.
$adObject = Get-ADComputer -Server $env:COMPUTERNAME -Filter "Name -eq '$($entry.Name)'"
if ($adObject) {
$result.Status = 'DomainManaged'
} else {
$records = @(Get-DnsServerResourceRecord -ZoneName $manifest.Zone -Name $entry.Name -ErrorAction SilentlyContinue)
if ($records.Count -gt 0 -and ($records.Count -ne 1 -or $records[0].RecordType -ne 'A' -or
$records[0].RecordData.IPv4Address.IPAddressToString -ne $entry.LastPublishedIP)) {
throw 'DNS record differs from the owned record; refusing to overwrite it.'
}
$addresses = @(Resolve-DnsName -Name "$($entry.Name)." -Server $manifest.RouterDns -Type A -DnsOnly -QuickTimeout |
Where-Object Type -eq A | Select-Object -ExpandProperty IPAddress -Unique)
if ($addresses.Count -ne 1 -or $addresses[0] -notmatch '^192\.168\.55\.(\d{1,3})$' -or
[int]$Matches[1] -lt 2 -or [int]$Matches[1] -gt 254) {
throw 'Router did not return a single host address in Sala Inmersiva.'
}
$address = $addresses[0]
if ($records.Count -eq 0) {
Add-DnsServerResourceRecordA -ZoneName $manifest.Zone -Name $entry.Name -IPv4Address $address -TimeToLive ([TimeSpan]::FromMinutes(5))
$result.Status = 'Created'
} elseif ($address -ne $entry.LastPublishedIP) {
$updated = $records[0].Clone()
$updated.RecordData.IPv4Address = [Net.IPAddress]::Parse($address)
$updated.TimeToLive = [TimeSpan]::FromMinutes(5)
Set-DnsServerResourceRecord -ZoneName $manifest.Zone -OldInputObject $records[0] -NewInputObject $updated
$result.Status = 'Updated'
} else {
$result.Status = 'Current'
}
$entry.LastPublishedIP = $address
$result.IP = $address
}
} catch {
$result.Status = 'Error'
$result.Error = $_.Exception.Message
$failed = $true
}
$results += [pscustomobject]$result
}
# A failed router query preserves the last record. TTL limits client caching,
# not record lifetime: operators must review errors instead of assuming freshness.
$manifest | ConvertTo-Json -Depth 5 | Set-Content -LiteralPath "$ManifestPath.next" -Encoding UTF8
Move-Item -LiteralPath "$ManifestPath.next" -Destination $ManifestPath -Force
[pscustomobject]@{ Time = (Get-Date).ToString('o'); Records = $results } |
ConvertTo-Json -Depth 5 | Set-Content -LiteralPath (Join-Path (Split-Path $ManifestPath) 'last-result.json') -Encoding UTF8
$results
# When installed, also preserve bare-name answers for workgroup clients on Sala.
$shortNameSync = Join-Path $PSScriptRoot 'Sync-SguSalaShortNames.ps1'
if (Test-Path -LiteralPath $shortNameSync) { & $shortNameSync -ManifestPath $ManifestPath }
if ($failed) { throw 'One or more Sala DNS records could not be synchronized. See last-result.json.' }
+103
View File
@@ -0,0 +1,103 @@
[CmdletBinding()]
param(
[Parameter(Mandatory)][uri]$Endpoint,
[Parameter(Mandatory)][PSCredential]$Credential,
[string]$DomainController = $env:COMPUTERNAME,
[string]$ComputerOuDn = '',
[string[]]$VerifyNodes = @()
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
Import-Module Microsoft.PowerShell.Utility
$base = $Endpoint.AbsoluteUri.TrimEnd('/')
$webSession = [Microsoft.PowerShell.Commands.WebRequestSession]::new()
# WAC v2's native form-login protocol, including CSRF and RSA-OAEP-SHA256.
# This signs in with the supplied existing account; no authentication settings
# or stored passwords are changed. Cookies remain only in this process.
try {
$page = Invoke-WebRequest -Uri "$base/" -WebSession $webSession -UseBasicParsing
$html = $page.Content
} catch {
if ([int]$_.Exception.Response.StatusCode -ne 403) { throw }
$reader = [IO.StreamReader]::new($_.Exception.Response.GetResponseStream())
try { $html = $reader.ReadToEnd() } finally { $reader.Dispose() }
}
$csrfMatch = [regex]::Match($html, 'var csrf\s*=\s*"([^"]+)"')
if (-not $csrfMatch.Success) {
$input = [regex]::Match($html, '<input\b[^>]*\bid="csrf"[^>]*>').Value
$csrfMatch = [regex]::Match($input, '\bvalue="([^"]+)"')
}
if (-not $csrfMatch.Success) { throw 'WAC form-login page did not supply a CSRF token.' }
$csrf = [Net.WebUtility]::HtmlDecode($csrfMatch.Groups[1].Value)
$key = Invoke-RestMethod -Uri "$base/api/user/key" -Method Post -WebSession $webSession `
-ContentType 'application/json' -Body (@{csrf=$csrf} | ConvertTo-Json -Compress)
function ConvertFrom-Base64Url([string]$Text) {
$text = $Text.Replace('-', '+').Replace('_', '/')
while ($text.Length % 4) { $text += '=' }
return [Convert]::FromBase64String($text)
}
$rsa = [Security.Cryptography.RSACng]::new()
try {
$parameters = [Security.Cryptography.RSAParameters]::new()
$parameters.Modulus = ConvertFrom-Base64Url $key.jwk.n
$parameters.Exponent = ConvertFrom-Base64Url $key.jwk.e
$rsa.ImportParameters($parameters)
$plainPassword = ([Net.NetworkCredential]::new('', $Credential.Password)).Password
$data = @{username=$Credential.UserName; password=$plainPassword; csrf=$csrf} | ConvertTo-Json -Compress
$bytes = [Text.Encoding]::UTF8.GetBytes($data)
$packet = [Convert]::ToBase64String($rsa.Encrypt($bytes, [Security.Cryptography.RSAEncryptionPadding]::OaepSHA256))
$plainPassword = $null; $data = $null
[Array]::Clear($bytes, 0, $bytes.Length)
} finally { $rsa.Dispose() }
$login = Invoke-WebRequest -Uri "$base/api/user/login" -Method Post -WebSession $webSession `
-UseBasicParsing -ContentType 'application/json' -Body (@{packet=$packet;csrf=$csrf} | ConvertTo-Json -Compress)
if ($login.StatusCode -ne 200) { throw 'WAC rejected the supplied account.' }
$existing = Invoke-RestMethod -Uri "$base/api/connections" -WebSession $webSession
$search = @{Server=$DomainController; Filter='Enabled -eq $true'; Properties=@('OperatingSystem','DNSHostName')}
if ($ComputerOuDn) {
Get-ADOrganizationalUnit -Identity $ComputerOuDn -Server $DomainController | Out-Null
$search.SearchBase = $ComputerOuDn
}
$computers = @(Get-ADComputer @search |
Where-Object { $_.DNSHostName -and $_.OperatingSystem -like 'Windows*' })
$pending = @(
foreach ($computer in $computers) {
$type = 'msft.sme.connection-type.windows-client'
if ($computer.OperatingSystem -like '*Server*') { $type = 'msft.sme.connection-type.server' }
$name = $computer.DNSHostName.ToLowerInvariant()
$id = "$type!$name!global"
$tags = @('Dominio', 'La Salle')
$current = $existing.value | Where-Object { $_.id -eq $id -or $_.name -eq $id -or
($_.properties.name -ieq $name -and $_.properties.type -eq $type -and $_.properties.groupId -eq 'global') }
if ($current) { continue }
[pscustomobject]@{name=$name;type=$type;tags=$tags;groupId='global';id=$id}
}
)
if ($pending.Count) {
$response = Invoke-RestMethod -Uri "$base/api/connections" -Method Put -WebSession $webSession `
-ContentType 'application/json' -Body (ConvertTo-Json -InputObject @($pending) -Depth 4)
if ($response.errors) { throw ($response.errors | ConvertTo-Json -Depth 4) }
}
$verified = Invoke-RestMethod -Uri "$base/api/connections" -WebSession $webSession
$shared = @($verified.value | Where-Object { $_.properties.groupId -eq 'global' })
$missing = @($computers | Where-Object {
$shared.properties.name -inotcontains $_.DNSHostName
})
if ($missing.Count) { throw "WAC inventory verification failed: $($missing.Name -join ', ')" }
[pscustomobject]@{DomainComputers=$computers.Count;Added=$pending.Count;SharedConnections=$shared.Count;Missing=$missing.Count}
foreach ($node in $VerifyNodes) {
if ($node -notmatch '^[A-Za-z0-9.-]+$') { throw 'Invalid verification hostname.' }
$uri = "$base/api/services/WinREST/CIM/nodes/$node/namespaces/root.cimv2/classes/Win32_OperatingSystem/instances"
try {
$response = Invoke-WebRequest -Uri $uri -WebSession $webSession -UseBasicParsing
$result = $response.Content | ConvertFrom-Json
$instances = @($result.value | Where-Object { $null -ne $_ })
if (-not $instances.Count) { throw "WAC returned no OS instances for $node." }
[pscustomobject]@{Node=$node;Status=$response.StatusCode;Instances=$instances.Count;ReturnedData=$true;Error=$null}
} catch {
# An offline node must not prevent verification of the remaining nodes.
[pscustomobject]@{Node=$node;Status=$null;Instances=0;ReturnedData=$false;Error=$_.Exception.Message}
}
}
+73
View File
@@ -0,0 +1,73 @@
[CmdletBinding()]
param(
[Parameter(Mandatory)][PSCredential]$Credential,
[string]$TargetOuDn = 'OU=Centro de Experiencia Digital,OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$Ssid = 'Centro de Experiencia Digital',
[ValidatePattern('^[A-Za-z0-9]{3}$')][string]$SiteCode = 'LCI',
[string]$WacThumbprint = 'CF2B7C6899885BF9EB0E59054F8E8AB2D4390513'
)
$ErrorActionPreference = 'Stop'
Import-Module ActiveDirectory
Clear-DnsClientCache
$computers = @(Get-ADComputer -SearchBase $TargetOuDn -Filter 'Enabled -eq $true' -Properties DNSHostName)
$notification = @{}
$notificationError = $null
try {
foreach ($resource in (Get-CimInstance -Namespace ("root\SMS\site_"+$SiteCode) -ClassName SMS_CombinedDeviceResources)) {
$notification[$resource.Name] = $resource
}
} catch { $notificationError = $_.Exception.Message }
function Add-NotificationStatus($result) {
$resource = $notification[$result.Name]
# Null means no provider data, not a confirmed offline client.
$result | Add-Member -NotePropertyMembers @{
NotificationOnline = $(if ($resource) { $resource.CNIsOnline } else { $null })
NotificationMP = $(if ($resource) { $resource.CNAccessMP } else { $null })
NotificationLastOnlineTime = $(if ($resource) { $resource.CNLastOnlineTime } else { $null })
NotificationQueryError = $notificationError
} -PassThru
}
$online = @()
foreach ($computer in $computers) {
$client = [Net.Sockets.TcpClient]::new()
try {
$connect = $client.BeginConnect($computer.DNSHostName,5985,$null,$null)
$available = $connect.AsyncWaitHandle.WaitOne(1000) -and $client.Connected
} catch { $available = $false } finally { $client.Dispose() }
if ($available) { $online += $computer.DNSHostName }
else { Add-NotificationStatus ([pscustomobject]@{Name=$computer.Name;Reachable=$false;WifiConnected=$false;ClientRunning=$false;Error='No WinRM TCP connection at current DNS address.'}) }
}
$options = New-PSSessionOption -OpenTimeout 10000 -OperationTimeout 60000
if ($online.Count) {
$reported = @(Invoke-Command -ComputerName $online -Credential $Credential -Authentication Kerberos -SessionOption $options -ErrorAction Continue -ArgumentList $Ssid,$WacThumbprint -ScriptBlock {
param($ssid,$thumbprint)
$liveSsid = @([Windows.Networking.Connectivity.NetworkInformation,Windows.Networking.Connectivity,ContentType=WindowsRuntime]::GetConnectionProfiles() | Where-Object IsWlanConnectionProfile | ForEach-Object { $_.WlanConnectionProfileDetails.GetConnectedSsid() })
$event = Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-WLAN-AutoConfig/Operational';Id=8001} -MaxEvents 1 -ErrorAction SilentlyContinue
$profile = $null; $authentication = $null
if ($event) {
[xml]$xml = $event.ToXml()
$profile = ($xml.Event.EventData.Data | Where-Object Name -eq ProfileName).'#text'
$authentication = ($xml.Event.EventData.Data | Where-Object Name -eq AuthenticationAlgorithm).'#text'
}
$service = Get-Service CcmExec -ErrorAction SilentlyContinue
$version = $null; $site = $null
if ($service.Status -eq 'Running') {
$sms = Get-CimInstance -Namespace root\ccm -ClassName SMS_Client -ErrorAction SilentlyContinue
$version = $sms.ClientVersion
$site = (Invoke-CimMethod -Namespace root\ccm -ClassName SMS_Client -MethodName GetAssignedSite -ErrorAction SilentlyContinue).sSiteCode
}
[pscustomobject]@{
Name=$env:COMPUTERNAME;Reachable=$true;SSID=$liveSsid -join ',';Profile=$profile
WifiConnected=($liveSsid -contains $ssid -and $profile -eq $ssid)
IP=@(Get-NetIPAddress -AddressFamily IPv4 | Where-Object IPAddress -like '192.168.*' | ForEach-Object IPAddress) -join ','
Authentication=$authentication;ClientRunning=($service.Status -eq 'Running');ClientVersion=$version;Site=$site
WacRootTrusted=(Test-Path ("Cert:\LocalMachine\Root\"+$thumbprint));Error=$null
}
})
foreach ($result in $reported) { Add-NotificationStatus $result }
foreach ($hostname in $online) {
if ($reported.PSComputerName -inotcontains $hostname) {
Add-NotificationStatus ([pscustomobject]@{Name=$hostname.Split('.')[0];Reachable=$false;WifiConnected=$false;ClientRunning=$false;Error='WinRM session or client verification failed after TCP probe.'})
}
}
}
@@ -13,7 +13,8 @@ public sealed record InstitutionalProfile(
string? City = null, string? City = null,
string? State = null, string? State = null,
string? PostalCode = null, string? PostalCode = null,
InstitutionalGender? Gender = null) InstitutionalGender? Gender = null,
byte[]? ThumbnailPhoto = null)
{ {
public bool HasValues => public bool HasValues =>
EmployeeNumber is not null || EmployeeNumber is not null ||
@@ -28,7 +29,8 @@ public sealed record InstitutionalProfile(
City is not null || City is not null ||
State is not null || State is not null ||
PostalCode is not null || PostalCode is not null ||
Gender is not null; Gender is not null ||
ThumbnailPhoto is not null;
public InstitutionalProfile Overlay(InstitutionalProfile? values) => public InstitutionalProfile Overlay(InstitutionalProfile? values) =>
values is null values is null
@@ -47,6 +49,7 @@ public sealed record InstitutionalProfile(
City = values.City ?? City, City = values.City ?? City,
State = values.State ?? State, State = values.State ?? State,
PostalCode = values.PostalCode ?? PostalCode, PostalCode = values.PostalCode ?? PostalCode,
Gender = values.Gender ?? Gender Gender = values.Gender ?? Gender,
ThumbnailPhoto = values.ThumbnailPhoto ?? ThumbnailPhoto
}; };
} }
+5
View File
@@ -17,10 +17,15 @@ internal static class BrokerEventIds
internal static readonly EventId ProfileEnrichmentTimeout = new(1202, nameof(ProfileEnrichmentTimeout)); internal static readonly EventId ProfileEnrichmentTimeout = new(1202, nameof(ProfileEnrichmentTimeout));
internal static readonly EventId ProfileEnrichmentFailure = new(1203, nameof(ProfileEnrichmentFailure)); internal static readonly EventId ProfileEnrichmentFailure = new(1203, nameof(ProfileEnrichmentFailure));
internal static readonly EventId ProfilePageUnavailable = new(1204, nameof(ProfilePageUnavailable)); internal static readonly EventId ProfilePageUnavailable = new(1204, nameof(ProfilePageUnavailable));
internal static readonly EventId ProfilePhotoUnavailable = new(1205, nameof(ProfilePhotoUnavailable));
internal static readonly EventId ProfilePhotoInvalid = new(1206, nameof(ProfilePhotoInvalid));
internal static readonly EventId DirectorySynchronizationFailure = new(1300, nameof(DirectorySynchronizationFailure)); internal static readonly EventId DirectorySynchronizationFailure = new(1300, nameof(DirectorySynchronizationFailure));
internal static readonly EventId DirectoryOptionalMetadataFailure = new(1301, nameof(DirectoryOptionalMetadataFailure)); internal static readonly EventId DirectoryOptionalMetadataFailure = new(1301, nameof(DirectoryOptionalMetadataFailure));
internal static readonly EventId DirectoryGroupMembershipFailure = new(1302, nameof(DirectoryGroupMembershipFailure)); internal static readonly EventId DirectoryGroupMembershipFailure = new(1302, nameof(DirectoryGroupMembershipFailure));
internal static readonly EventId DirectoryRoleGroupMembershipAdded = new(1303, nameof(DirectoryRoleGroupMembershipAdded)); internal static readonly EventId DirectoryRoleGroupMembershipAdded = new(1303, nameof(DirectoryRoleGroupMembershipAdded));
internal static readonly EventId DirectoryPasswordChangeDenied = new(1304, nameof(DirectoryPasswordChangeDenied)); internal static readonly EventId DirectoryPasswordChangeDenied = new(1304, nameof(DirectoryPasswordChangeDenied));
internal static readonly EventId DirectoryPhotoFailure = new(1305, nameof(DirectoryPhotoFailure));
internal static readonly EventId DirectoryReversiblePasswordEncryptionEnabled = new(1306, nameof(DirectoryReversiblePasswordEncryptionEnabled));
internal static readonly EventId DirectoryReversiblePasswordEncryptionDisabled = new(1307, nameof(DirectoryReversiblePasswordEncryptionDisabled));
} }
+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)
+1
View File
@@ -11,6 +11,7 @@
<ProjectReference Include="..\SGU.AuthBroker.Core\SGU.AuthBroker.Core.csproj" /> <ProjectReference Include="..\SGU.AuthBroker.Core\SGU.AuthBroker.Core.csproj" />
<PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="10.0.11" /> <PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="10.0.11" />
<PackageReference Include="System.DirectoryServices" Version="10.0.11" /> <PackageReference Include="System.DirectoryServices" Version="10.0.11" />
<PackageReference Include="System.Drawing.Common" Version="10.0.11" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
@@ -17,6 +17,7 @@ public sealed class ActiveDirectorySynchronizer(
private const int InfoAttributeMaximumLength = 1024; private const int InfoAttributeMaximumLength = 1024;
private const int AccountDisabled = 0x0002; private const int AccountDisabled = 0x0002;
private const int NormalAccount = 0x0200; private const int NormalAccount = 0x0200;
private const int ReversiblePasswordEncryptionAllowed = 0x0080;
private static readonly Guid ChangePasswordExtendedRight = private static readonly Guid ChangePasswordExtendedRight =
new("AB721A53-1E2F-11D0-9819-00AA0040529B"); new("AB721A53-1E2F-11D0-9819-00AA0040529B");
private static readonly SecurityIdentifier EveryoneSid = private static readonly SecurityIdentifier EveryoneSid =
@@ -131,6 +132,10 @@ public sealed class ActiveDirectorySynchronizer(
// which ADSI SetPassword uses for each successful authentication. // which ADSI SetPassword uses for each successful authentication.
EnsureCannotChangePassword(user, identity.UserName); EnsureCannotChangePassword(user, identity.UserName);
// Keep reversible storage disabled for SGU users. Clear the account
// flag before writing the password so this reset uses one-way storage.
EnsureReversiblePasswordEncryptionDisabled(user, identity.UserName);
// The exact institutional password received by the broker is passed to AD. // The exact institutional password received by the broker is passed to AD.
// It is not derived, transformed, written to disk, or included in logs. // It is not derived, transformed, written to disk, or included in logs.
user.Invoke("SetPassword", [password]); user.Invoke("SetPassword", [password]);
@@ -142,6 +147,7 @@ public sealed class ActiveDirectorySynchronizer(
user.CommitChanges(); user.CommitChanges();
TryApplyProfile(user, identity, profile, options.DefaultCompany, logger); TryApplyProfile(user, identity, profile, options.DefaultCompany, logger);
TryApplyPhoto(user, identity.UserName, profile?.ThumbnailPhoto);
TryEnsureRemoteDesktopGroupMembership(user, identity.UserName); TryEnsureRemoteDesktopGroupMembership(user, identity.UserName);
return new DirectorySyncResult( return new DirectorySyncResult(
@@ -174,6 +180,23 @@ public sealed class ActiveDirectorySynchronizer(
institutionalUser); institutionalUser);
} }
private void EnsureReversiblePasswordEncryptionDisabled(DirectoryEntry user, string institutionalUser)
{
object? rawFlags = user.Properties["userAccountControl"].Value;
int flags = rawFlags is null ? NormalAccount : Convert.ToInt32(rawFlags);
if ((flags & ReversiblePasswordEncryptionAllowed) == 0)
{
return;
}
user.Properties["userAccountControl"].Value = flags & ~ReversiblePasswordEncryptionAllowed;
user.CommitChanges();
logger.LogInformation(
BrokerEventIds.DirectoryReversiblePasswordEncryptionDisabled,
"Disabled reversible password storage for SGU-managed Active Directory user {InstitutionalUser}.",
institutionalUser);
}
internal static bool EnsureCannotChangePassword(ActiveDirectorySecurity security) internal static bool EnsureCannotChangePassword(ActiveDirectorySecurity security)
{ {
bool changed = false; bool changed = false;
@@ -264,6 +287,42 @@ public sealed class ActiveDirectorySynchronizer(
} }
} }
private void TryApplyPhoto(DirectoryEntry user, string institutionalUser, byte[]? photo)
{
if (photo is null)
{
return;
}
try
{
if (user.Properties["thumbnailPhoto"].Value is byte[] existing &&
existing.AsSpan().SequenceEqual(photo))
{
return;
}
user.Properties["thumbnailPhoto"].Value = photo;
user.CommitChanges();
}
catch (Exception exception)
{
logger.LogWarning(
BrokerEventIds.DirectoryPhotoFailure,
exception,
"Optional Active Directory thumbnailPhoto could not be committed for {InstitutionalUser}; account synchronization remains completed.",
institutionalUser);
try
{
user.RefreshCache();
}
catch
{
// Photo metadata must not change the successful authentication result.
}
}
}
private static void SetGenderMetadata( private static void SetGenderMetadata(
DirectoryEntry entry, DirectoryEntry entry,
InstitutionalGender? gender, InstitutionalGender? gender,
@@ -1,4 +1,6 @@
using System.Diagnostics; using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Net; using System.Net;
using System.Text; using System.Text;
using System.Text.Json; using System.Text.Json;
@@ -11,6 +13,9 @@ namespace SGU.AuthBroker.Services;
public sealed class NtlmCredentialValidator : INtlmCredentialValidator public sealed class NtlmCredentialValidator : INtlmCredentialValidator
{ {
private const int MaximumPhotoBytes = 100 * 1024;
private const int MinimumPhotoBytes = 128;
private static readonly TimeSpan PhotoTimeout = TimeSpan.FromSeconds(3);
private readonly NtlmOptions options; private readonly NtlmOptions options;
private readonly ILogger<NtlmCredentialValidator> logger; private readonly ILogger<NtlmCredentialValidator> logger;
private readonly Func<CredentialCache, CookieContainer, HttpMessageHandler> handlerFactory; private readonly Func<CredentialCache, CookieContainer, HttpMessageHandler> handlerFactory;
@@ -353,6 +358,20 @@ public sealed class NtlmCredentialValidator : INtlmCredentialValidator
elapsed).ConfigureAwait(false); elapsed).ConfigureAwait(false);
} }
if (string.Equals(profile?.EmployeeNumber, identity.NumericId, StringComparison.Ordinal))
{
byte[]? photo = await TryFetchPhotoAsync(
client,
identity,
allowedHosts,
timeout.Token,
cancellationToken).ConfigureAwait(false);
if (photo is not null)
{
profile = profile! with { ThumbnailPhoto = photo };
}
}
if (profile is null) if (profile is null)
{ {
logger.LogWarning( logger.LogWarning(
@@ -680,6 +699,135 @@ public sealed class NtlmCredentialValidator : INtlmCredentialValidator
return null; return null;
} }
private async Task<byte[]?> TryFetchPhotoAsync(
HttpClient client,
UserIdentity identity,
HashSet<string> allowedHosts,
CancellationToken profileTimeoutToken,
CancellationToken requestCancellationToken)
{
// Only a number verified against the authenticated profile is used.
// Never follow an image URL supplied by SGU HTML to an arbitrary host.
int photoType = identity.Role == InstitutionalRole.Student ? 1 : 2;
Uri photoUri = GetProfileUri(
$"/psulsa/gadmon/admonPersonal/ashx/Fotografia.ashx?id={identity.NumericId}&tp={photoType}");
if (!IsAllowedHttpsUri(photoUri, allowedHosts))
{
return null;
}
using CancellationTokenSource timeout = CancellationTokenSource.CreateLinkedTokenSource(profileTimeoutToken);
timeout.CancelAfter(PhotoTimeout);
try
{
using HttpRequestMessage request = new(HttpMethod.Get, photoUri);
using HttpResponseMessage response = await client.SendAsync(
request,
HttpCompletionOption.ResponseHeadersRead,
timeout.Token).ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
logger.LogWarning(
BrokerEventIds.ProfilePhotoUnavailable,
"SGU photo for role {Role} returned HTTP {StatusCode}; preserving existing Active Directory photo.",
identity.Role,
(int)response.StatusCode);
return null;
}
if (!string.Equals(
response.Content.Headers.ContentType?.MediaType,
"image/jpeg",
StringComparison.OrdinalIgnoreCase) ||
response.Content.Headers.ContentLength is > MaximumPhotoBytes)
{
logger.LogWarning(
BrokerEventIds.ProfilePhotoInvalid,
"SGU photo for role {Role} had an unsupported media type or size; preserving existing Active Directory photo.",
identity.Role);
return null;
}
await using Stream stream = await response.Content.ReadAsStreamAsync(timeout.Token)
.ConfigureAwait(false);
using MemoryStream buffer = new();
byte[] chunk = new byte[8192];
while (true)
{
int read = await stream.ReadAsync(chunk.AsMemory(), timeout.Token).ConfigureAwait(false);
if (read == 0)
{
break;
}
if (buffer.Length + read > MaximumPhotoBytes)
{
logger.LogWarning(
BrokerEventIds.ProfilePhotoInvalid,
"SGU photo for role {Role} exceeded the size limit; preserving existing Active Directory photo.",
identity.Role);
return null;
}
buffer.Write(chunk, 0, read);
}
byte[] photo = buffer.ToArray();
if (photo.Length < MinimumPhotoBytes ||
photo[0] != 0xFF || photo[1] != 0xD8 || photo[2] != 0xFF ||
photo[^2] != 0xFF || photo[^1] != 0xD9 ||
!IsDecodableJpeg(photo))
{
logger.LogWarning(
BrokerEventIds.ProfilePhotoInvalid,
"SGU photo for role {Role} was not a valid JPEG payload; preserving existing Active Directory photo.",
identity.Role);
return null;
}
return photo;
}
catch (OperationCanceledException) when (requestCancellationToken.IsCancellationRequested)
{
throw;
}
catch (OperationCanceledException)
{
logger.LogWarning(
BrokerEventIds.ProfilePhotoUnavailable,
"SGU photo request for role {Role} timed out; preserving existing Active Directory photo.",
identity.Role);
}
catch (Exception exception)
{
logger.LogWarning(
BrokerEventIds.ProfilePhotoUnavailable,
exception,
"SGU photo request for role {Role} failed; preserving existing Active Directory photo.",
identity.Role);
}
return null;
}
private static bool IsDecodableJpeg(byte[] photo)
{
try
{
using MemoryStream input = new(photo, writable: false);
using Image image = Image.FromStream(input, useEmbeddedColorManagement: false, validateImageData: true);
return image.RawFormat.Guid == ImageFormat.Jpeg.Guid &&
image.Width is >= 1 and <= 4096 &&
image.Height is >= 1 and <= 4096;
}
catch (Exception)
{
// Image decoding is optional metadata validation; malformed input
// from the portal must never interrupt account provisioning.
return false;
}
}
private async Task<string?> TryPostProfilePageMethodAsync( private async Task<string?> TryPostProfilePageMethodAsync(
HttpClient client, HttpClient client,
Uri requestedUri, Uri requestedUri,
+2 -1
View File
@@ -67,7 +67,8 @@ internal sealed class BrokerClient : IDisposable
return BrokerDecision.Authorized(authorized.Domain, authorized.UserName); return BrokerDecision.Authorized(authorized.Domain, authorized.UserName);
} }
return BrokerDecision.Unavailable($"BROKER_HTTP_{(int)response.StatusCode}"); ErrorBody? unavailable = await ReadJsonAsync<ErrorBody>(response, timeout.Token).ConfigureAwait(false);
return BrokerDecision.Unavailable(unavailable?.Code ?? $"BROKER_HTTP_{(int)response.StatusCode}");
} }
catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested) catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
{ {
@@ -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);
@@ -43,7 +43,12 @@ public sealed class SguCredentialProvider : CredentialProviderBase
public override bool ShouldIncludeGenericTile() => true; public override bool ShouldIncludeGenericTile() => true;
public override CredentialTile CreateGenericTile() => new SguCredentialTile(this); public override CredentialTile CreateGenericTile()
{
SguCredentialTile tile = new(this);
DefaultTile = tile;
return tile;
}
public override CredentialTile2 CreateUserTile(CredentialProviderUser user) => public override CredentialTile2 CreateUserTile(CredentialProviderUser user) =>
new SguCredentialTile(this, user); new SguCredentialTile(this, user);
+81 -23
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,35 @@ 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 explicit SGU rejection is authoritative even when an older AD
? decision.Domain! // verifier for the same institutional key still exists.
: settings.DomainNetbios; if (decision.Kind == BrokerDecisionKind.InvalidCredentials)
string userName = decision.Kind == BrokerDecisionKind.Authorized
? decision.UserName!
: identity.UserName;
return new CredentialResponseSecure
{ {
IsSuccess = true, return Failure("Usuario o contraseña incorrectos.");
StatusIcon = decision.Kind == BrokerDecisionKind.Unavailable ? StatusIcon.Warning : StatusIcon.None, }
StatusText = decision.Kind == BrokerDecisionKind.Unavailable
? "Servicio institucional no disponible; Windows validará la última contraseña de dominio registrada." // SGU accepted this password but AD could not record it. Windows
: null, // must not attempt a logon against a stale AD password.
Domain = domain, if (decision.ErrorCode == "DIRECTORY_SYNCHRONIZATION_FAILED")
Username = userName, {
Password = securePassword return Failure("La contraseña institucional fue aceptada, pero no se pudo preparar la cuenta en Active Directory. Intenta nuevamente o contacta a soporte.");
}; }
// Only a genuine broker/SGU outage permits the documented cached
// domain-credential path for an existing account.
return DomainCredential(
domain,
userName,
securePassword,
"El servicio de autenticación no está disponible; Windows validará la última contraseña de dominio registrada.");
} }
finally finally
{ {
@@ -111,6 +124,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,
@@ -2,9 +2,15 @@ $repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
$synchronizerPath = Join-Path $repositoryRoot 'src\SGU.AuthBroker\Services\ActiveDirectorySynchronizer.cs' $synchronizerPath = Join-Path $repositoryRoot 'src\SGU.AuthBroker\Services\ActiveDirectorySynchronizer.cs'
$deployPath = Join-Path $repositoryRoot 'scripts\Deploy-AuthBroker.ps1' $deployPath = Join-Path $repositoryRoot 'scripts\Deploy-AuthBroker.ps1'
$userPolicyPath = Join-Path $repositoryRoot 'scripts\Set-SguDomainUserPolicies.ps1' $userPolicyPath = Join-Path $repositoryRoot 'scripts\Set-SguDomainUserPolicies.ps1'
$passwordPolicyPath = Join-Path $repositoryRoot 'scripts\Set-SguInstitutionalPasswordPolicy.ps1'
$bootstrapPath = Join-Path $repositoryRoot 'scripts\Initialize-SguDomainController.ps1'
$packagePath = Join-Path $repositoryRoot 'scripts\New-SguBootstrapPackages.ps1'
$synchronizer = Get-Content -LiteralPath $synchronizerPath -Raw $synchronizer = Get-Content -LiteralPath $synchronizerPath -Raw
$deploy = Get-Content -LiteralPath $deployPath -Raw $deploy = Get-Content -LiteralPath $deployPath -Raw
$userPolicy = Get-Content -LiteralPath $userPolicyPath -Raw $userPolicy = Get-Content -LiteralPath $userPolicyPath -Raw
$passwordPolicy = Get-Content -LiteralPath $passwordPolicyPath -Raw
$bootstrap = Get-Content -LiteralPath $bootstrapPath -Raw
$package = Get-Content -LiteralPath $packagePath -Raw
Describe 'SGU Auth Broker password authority' { Describe 'SGU Auth Broker password authority' {
It 'denies the Change Password extended right to SELF and Everyone before SetPassword' { It 'denies the Change Password extended right to SELF and Everyone before SetPassword' {
@@ -25,4 +31,17 @@ Describe 'SGU Auth Broker password authority' {
$userPolicy | Should Match "disableChangePasswordValueName = 'DisableChangePassword'" $userPolicy | Should Match "disableChangePasswordValueName = 'DisableChangePassword'"
$userPolicy | Should Match '(?s)-ValueName \$disableChangePasswordValueName.*-Type DWord.*-Value 1' $userPolicy | Should Match '(?s)-ValueName \$disableChangePasswordValueName.*-Type DWord.*-Value 1'
} }
It 'scopes exact SGU passwords to all three SGU role groups without changing the domain default' {
foreach ($role in @('Alumnos', 'Administrativos', 'Docentes')) {
$passwordPolicy | Should Match "CN=SGU-$role,OU=$role,OU=Usuarios-SGU"
}
$passwordPolicy | Should Match 'ComplexityEnabled = \$false'
$passwordPolicy | Should Match 'MinPasswordLength = 1'
$passwordPolicy | Should Match 'PasswordHistoryCount = 0'
$passwordPolicy | Should Match 'MaxPasswordAge = \[TimeSpan\]::Zero'
$passwordPolicy | Should Not Match 'Set-ADDefaultDomainPasswordPolicy'
$bootstrap | Should Match 'Set-SguInstitutionalPasswordPolicy\.ps1'
$package | Should Match "'Set-SguInstitutionalPasswordPolicy.ps1'"
}
} }
@@ -0,0 +1,32 @@
$repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
$installerPath = Join-Path $repositoryRoot 'scripts\Install-SguCredentialProviderUpdatePolicy.ps1'
Describe 'Credential Provider startup policy' {
It 'generates a complete LastLoggedOnProvider command' {
$Version = '0.6.16'
$ClientPackageUri = 'https://example.invalid/client.zip'
$ClientPackageSha256 = 'A' * 64
$source = Get-Content -LiteralPath $installerPath -Raw
$template = [regex]::Match($source, '(?ms)^\$startupScript = @"\r?\n.*?^"@')
$template.Success | Should Be $true
Invoke-Expression $template.Value
$tokens = $null
$errors = $null
$ast = [Management.Automation.Language.Parser]::ParseInput(
$startupScript, [ref]$tokens, [ref]$errors)
$errors.Count | Should Be 0
$commands = @($ast.FindAll({
param($node)
$node -is [Management.Automation.Language.CommandAst] -and
$node.GetCommandName() -eq 'Set-ItemProperty'
}, $true))
$commands.Count | Should Be 1
@($commands[0].CommandElements | Where-Object {
$_ -is [Management.Automation.Language.CommandParameterAst] -and
$_.ParameterName -eq 'Value'
}).Count | Should Be 1
$startupScript | Should Not Match '(?m)^\s+-Value\s'
}
}
@@ -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,
@@ -1,5 +1,7 @@
using System.Net; using System.Net;
using System.Net.Http.Headers; using System.Net.Http.Headers;
using System.Drawing;
using System.Drawing.Imaging;
using Microsoft.Extensions.Logging.Abstractions; using Microsoft.Extensions.Logging.Abstractions;
using SGU.AuthBroker.Core.Authentication; using SGU.AuthBroker.Core.Authentication;
using SGU.AuthBroker.Core.Identity; using SGU.AuthBroker.Core.Identity;
@@ -163,7 +165,8 @@ public sealed class NtlmCredentialValidatorTests
"""), """),
JsonResponse(""" JsonResponse("""
{"d":[{"p_IdCP":"090001","p_Nombre":"FLORIDA","p_Cp":"01000"}]} {"d":[{"p_IdCP":"090001","p_Nombre":"FLORIDA","p_Cp":"01000"}]}
""")); """),
PhotoResponse(TestJpeg()));
NtlmCredentialValidator validator = CreateValidator(handler); NtlmCredentialValidator validator = CreateValidator(handler);
NtlmValidationResult result = await validator.ValidateAsync( NtlmValidationResult result = await validator.ValidateAsync(
@@ -184,6 +187,7 @@ public sealed class NtlmCredentialValidatorTests
Assert.Equal("Ciudad de México", result.Profile.State); Assert.Equal("Ciudad de México", result.Profile.State);
Assert.Equal("01000", result.Profile.PostalCode); Assert.Equal("01000", result.Profile.PostalCode);
Assert.Equal(InstitutionalGender.Female, result.Profile.Gender); Assert.Equal(InstitutionalGender.Female, result.Profile.Gender);
Assert.Equal(TestJpeg(), result.Profile.ThumbnailPhoto);
Assert.Equal( Assert.Equal(
[ [
"/psulsa/", "/psulsa/",
@@ -193,7 +197,8 @@ public sealed class NtlmCredentialValidatorTests
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx", "/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx",
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetDireccion", "/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetDireccion",
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetLocalidadListado", "/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetLocalidadListado",
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetColoniasListado" "/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetColoniasListado",
"/psulsa/gadmon/admonPersonal/ashx/Fotografia.ashx"
], ],
handler.RequestPaths); handler.RequestPaths);
Assert.Equal("{\"CodigoPostal\":\"01000\"}", handler.RequestBodies[5]); Assert.Equal("{\"CodigoPostal\":\"01000\"}", handler.RequestBodies[5]);
@@ -201,6 +206,9 @@ public sealed class NtlmCredentialValidatorTests
Assert.Equal( Assert.Equal(
"{\"pIdEstado\":\"\",\"pLocalidad\":\"\",\"CodigoPostal\":\"01000\"}", "{\"pIdEstado\":\"\",\"pLocalidad\":\"\",\"CodigoPostal\":\"01000\"}",
handler.RequestBodies[7]); handler.RequestBodies[7]);
Assert.Equal(
"https://sgu.example/psulsa/gadmon/admonPersonal/ashx/Fotografia.ashx?id=017045&tp=2",
handler.RequestUris[8]);
} }
[Fact] [Fact]
@@ -278,7 +286,8 @@ public sealed class NtlmCredentialValidatorTests
"""), """),
JsonResponse(""" JsonResponse("""
{"d":[{"p_IdCP":"090001","p_Nombre":"FLORIDA","p_Cp":"01000"}]} {"d":[{"p_IdCP":"090001","p_Nombre":"FLORIDA","p_Cp":"01000"}]}
""")); """),
Response(HttpStatusCode.NotFound));
NtlmCredentialValidator validator = CreateValidator(handler); NtlmCredentialValidator validator = CreateValidator(handler);
NtlmValidationResult result = await validator.ValidateAsync( NtlmValidationResult result = await validator.ValidateAsync(
@@ -311,9 +320,13 @@ public sealed class NtlmCredentialValidatorTests
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx", "/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx",
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetDireccion", "/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetDireccion",
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetLocalidadListado", "/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetLocalidadListado",
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetColoniasListado" "/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetColoniasListado",
"/psulsa/gadmon/admonPersonal/ashx/Fotografia.ashx"
], ],
handler.RequestPaths); handler.RequestPaths);
Assert.Equal(
"https://sgu.example/psulsa/gadmon/admonPersonal/ashx/Fotografia.ashx?id=123456&tp=2",
handler.RequestUris[9]);
} }
[Fact] [Fact]
@@ -347,6 +360,109 @@ public sealed class NtlmCredentialValidatorTests
handler.RequestPaths[3]); handler.RequestPaths[3]);
} }
[Fact]
public async Task VerifiedStudentReceivesPhotoFromAuthenticatedSguSession()
{
byte[] jpeg = TestJpeg();
SequenceHandler handler = new(
Challenge(),
Response(HttpStatusCode.OK),
Response(HttpStatusCode.OK,
"<span id=\"ctl00_contenedor_HistorialAlumno1_lblClaveAlumnoHP\">123456</span>"),
PhotoResponse(jpeg));
NtlmValidationResult result = await CreateValidator(handler).ValidateAsync(
Student,
"test-password",
TestContext.Current.CancellationToken);
Assert.Equal(NtlmValidationStatus.Valid, result.Status);
Assert.Equal(jpeg, result.Profile?.ThumbnailPhoto);
Assert.Equal(
"https://sgu.example/psulsa/gadmon/admonPersonal/ashx/Fotografia.ashx?id=123456&tp=1",
handler.RequestUris[3]);
}
[Theory]
[InlineData("text/html")]
[InlineData("image/jpeg")]
public async Task InvalidStudentPhotoDoesNotBlockAuthentication(string mediaType)
{
byte[] invalid = new byte[150];
invalid[0] = 0xFF;
invalid[1] = 0xD8;
invalid[2] = 0xFF;
invalid[^2] = 0xFF;
invalid[^1] = 0xD9;
SequenceHandler handler = new(
Challenge(),
Response(HttpStatusCode.OK),
Response(HttpStatusCode.OK,
"<span id=\"ctl00_contenedor_HistorialAlumno1_lblClaveAlumnoHP\">123456</span>"),
PhotoResponse(invalid, mediaType));
NtlmValidationResult result = await CreateValidator(handler).ValidateAsync(
Student,
"test-password",
TestContext.Current.CancellationToken);
Assert.Equal(NtlmValidationStatus.Valid, result.Status);
Assert.Equal("123456", result.Profile?.EmployeeNumber);
Assert.Null(result.Profile?.ThumbnailPhoto);
}
[Fact]
public async Task OversizedStudentPhotoDoesNotBlockAuthentication()
{
SequenceHandler handler = new(
Challenge(),
Response(HttpStatusCode.OK),
Response(HttpStatusCode.OK,
"<span id=\"ctl00_contenedor_HistorialAlumno1_lblClaveAlumnoHP\">123456</span>"),
PhotoResponse(new byte[100 * 1024 + 1]));
NtlmValidationResult result = await CreateValidator(handler).ValidateAsync(
Student,
"test-password",
TestContext.Current.CancellationToken);
Assert.Equal(NtlmValidationStatus.Valid, result.Status);
Assert.Equal("123456", result.Profile?.EmployeeNumber);
Assert.Null(result.Profile?.ThumbnailPhoto);
}
[Fact]
public async Task UnverifiedStudentNumberNeverFetchesPhoto()
{
SequenceHandler handler = new(
Challenge(),
Response(HttpStatusCode.OK),
Response(HttpStatusCode.OK,
"<span id=\"ctl00_contenedor_HistorialAlumno1_lblClaveAlumnoHP\">654321</span>"));
NtlmValidationResult result = await CreateValidator(handler).ValidateAsync(
Student,
"test-password",
TestContext.Current.CancellationToken);
Assert.Equal(NtlmValidationStatus.Valid, result.Status);
Assert.Null(result.Profile);
Assert.Equal(3, handler.RequestUris.Count);
}
private static byte[] TestJpeg()
{
using Bitmap bitmap = new(16, 16);
using MemoryStream output = new();
bitmap.Save(output, ImageFormat.Jpeg);
return output.ToArray();
}
private static HttpResponseMessage PhotoResponse(byte[] bytes, string mediaType = "image/jpeg") =>
new(HttpStatusCode.OK)
{
Content = new ByteArrayContent(bytes)
{
Headers = { ContentType = new MediaTypeHeaderValue(mediaType) }
}
};
private static NtlmCredentialValidator CreateValidator(SequenceHandler handler) private static NtlmCredentialValidator CreateValidator(SequenceHandler handler)
{ {
BrokerOptions options = new() BrokerOptions options = new()
@@ -406,6 +522,8 @@ public sealed class NtlmCredentialValidatorTests
public List<string> RequestPaths { get; } = []; public List<string> RequestPaths { get; } = [];
public List<string> RequestUris { get; } = [];
public List<string?> RequestBodies { get; } = []; public List<string?> RequestBodies { get; } = [];
protected override Task<HttpResponseMessage> SendAsync( protected override Task<HttpResponseMessage> SendAsync(
@@ -414,6 +532,7 @@ public sealed class NtlmCredentialValidatorTests
{ {
cancellationToken.ThrowIfCancellationRequested(); cancellationToken.ThrowIfCancellationRequested();
RequestPaths.Add(request.RequestUri!.AbsolutePath); RequestPaths.Add(request.RequestUri!.AbsolutePath);
RequestUris.Add(request.RequestUri.AbsoluteUri);
RequestBodies.Add(request.Content is null RequestBodies.Add(request.Content is null
? null ? null
: request.Content.ReadAsStringAsync(cancellationToken).GetAwaiter().GetResult()); : request.Content.ReadAsStringAsync(cancellationToken).GetAwaiter().GetResult());
@@ -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"
]; ];
@@ -89,6 +89,8 @@ internal static class Program
bool passed = fieldCount == ExpectedLabels.Length && bool passed = fieldCount == ExpectedLabels.Length &&
credentialCount == 1 && credentialCount == 1 &&
defaultIndex == 0 &&
autoLogon == 0 &&
credential != IntPtr.Zero && credential != IntPtr.Zero &&
providerLogoPresent && providerLogoPresent &&
!userTilePresent && !userTilePresent &&
@@ -146,7 +148,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 +186,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 +218,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,
@@ -46,6 +46,7 @@ public sealed class BrokerClientTests
TestContext.Current.CancellationToken); TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.InvalidCredentials, decision.Kind); Assert.Equal(BrokerDecisionKind.InvalidCredentials, decision.Kind);
Assert.Equal("INVALID_INSTITUTIONAL_CREDENTIALS", decision.ErrorCode);
} }
[Fact] [Fact]
@@ -61,6 +62,23 @@ public sealed class BrokerClientTests
TestContext.Current.CancellationToken); TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind); Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind);
Assert.Equal("NTLM_UPSTREAM_ERROR", decision.ErrorCode);
}
[Fact]
public async Task SynchronizationFailureRetainsItsSpecificErrorCode()
{
using BrokerClient client = new(
CreateSettings(),
new CapturingHandler(HttpStatusCode.ServiceUnavailable, "{\"code\":\"DIRECTORY_SYNCHRONIZATION_FAILED\"}"));
BrokerDecision decision = await client.AuthenticateAsync(
"AL250792",
"SGUAccepted",
TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind);
Assert.Equal("DIRECTORY_SYNCHRONIZATION_FAILED", decision.ErrorCode);
} }
private static ProviderSettings CreateSettings() => new() private static ProviderSettings CreateSettings() => new()
@@ -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);