Compare commits

...
19 Commits
Author SHA1 Message Date
alexrg 656f1dd3bb Preserve machine identity for initial WLAN policy retrieval 2026-10-14 21:54:25 -06:00
alexrg 5cda541e3d Consolidate laboratory network and client maintenance policies 2026-10-14 21:49:32 -06:00
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
65 changed files with 3711 additions and 41 deletions

No files matched your search

+1
View File
@@ -60,6 +60,7 @@ visible while the browser populates those controls asynchronously.
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)
- [Broker location, health, timeout, and recovery](docs/broker-operations.md)
- [Windows domain join and remote-access onboarding](docs/windows-client-onboarding.md)
+15 -3
View File
@@ -67,9 +67,21 @@ moves it to the mapped OU when required, sets `userPrincipalName`, and passes
that same password directly to ADSI `SetPassword`. This is an idempotent UPSERT
performed on every successful sign-in, so the next sign-in after an institutional
password change updates AD before Windows validates the interactive logon. If
SGU rejects the credential or is unavailable, the unchanged credentials go to
Windows; only an existing AD account can then authenticate. A matching username
pattern alone never provisions an account.
SGU explicitly rejects the credential, the provider stops without trying AD.
If 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
Active Directory `Change Password` extended right to SELF and Everyone. Users
+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
segundos**: si SGU excede ese presupuesto, Windows continúa por el fallback
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
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
+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)
+54
View File
@@ -0,0 +1,54 @@
# 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 principal `SGU-DC01` en `20.9.81.130` 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-DC01 con permisos de administración de dominio y GPO. Mantenga
juntos todos los archivos 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-DC01
.\Sync-SguCedWifiReaders.ps1 -DomainController SGU-DC01 -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. Los clientes priorizan DNS del controlador
principal y mantienen `SGU-DC02` solo como DNS de respaldo. Un bloque administrado
en `hosts` hace que el FQDN de `SGU-DC01` use su extremo público, sin cambiar la
dirección privada que los controladores usan para replicar. No hay contraseñas de
administrador en el cliente ni claves Wi-Fi en los scripts del paquete.
Configuration Manager se administra exclusivamente desde su GPO global de
SYSTEMCENTER. La GPO Wi-Fi no instala un segundo agente ni una tarea repetitiva.
Para consolidar el dominio existente, consulte `policy-consolidation.md` y use
`Merge-SguClientPolicies.ps1` en el principal.
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.
+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;
- `1200` enriquecimiento completado y cantidad de campos; `1201` HTML sin los
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;
`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
respuesta SGU.
Los registros no almacenan HTML, contraseñas, hashes ni cuerpos de respuesta
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
+96
View File
@@ -0,0 +1,96 @@
# Consolidación de políticas del laboratorio
La configuración vigente tiene un responsable por función. Las GPO se ven en
`gpmc.msc`; sus scripts se guardan en
`\\SGU-DC01.lci.lasalle.mx\SYSVOL\lci.lasalle.mx\Policies\{GUID}\Machine\Scripts`.
Las tareas se ven en `taskschd.msc` de cada equipo. Los servicios instalados se
administran en `services.msc`.
| Función | Responsable | Cuándo se ejecuta |
| --- | --- | --- |
| DNS del dominio en CED | CED - DNS de dominio; configuración compartida `ced-network.json` | Actualización nativa de políticas |
| Perfil Wi-Fi de AF, SD y SI | CED - Wi-Fi de salas; WLAN AutoConfig y `CED WiFi policy connection` | Arranque, políticas de equipo, cierre de sesión y conexión Wi-Fi |
| Proveedor de credenciales | SGU - Credential Provider update | Arranque; comprueba la instalación antes de descargar |
| RDP, WinRM y firewall de administración | La Salle - Workstation remote management | GPO nativa y un único auxiliar de arranque |
| Agente ConfigMgr | LCI-ConfigMgr2509-ClientRegistration; SYSTEMCENTER | Registro de la tarea por GPO, arranque y disponibilidad de red |
| Agente SCOM | LCI - SCOM agent deployment; SYSTEMCENTER | Registro de la tarea por GPO, arranque y disponibilidad de red |
| Inventario auxiliar de Azure | SGU-Monitoring-Inventory | Cada hora; no representa el monitoreo continuo de SCOM |
| Retención de eventos | SGU-Monitoring-Retention | Diariamente |
ConfigMgr y SCOM conservan sus instaladores con comprobación de versión, sitio,
clave de confianza o grupo de administración. Ya no tienen un temporizador de
30 minutos. Sus tareas permiten dos reintentos a intervalos de cinco minutos
solo cuando falla una ejecución. Para publicar una nueva versión del agente,
actualice el origen de SYSTEMCENTER y su GPO; un arranque o una conexión de red
también vuelve a comprobar la versión. Los agentes continúan funcionando entre
estas comprobaciones.
La GPO Wi-Fi deja de instalar ConfigMgr. La GPO de experiencia de Windows
conserva la configuración visual y el auxiliar de administradores, pero deja
de repetir la configuración de acceso remoto. El guardián antiguo del proveedor
se deshabilita cuando se verifican proveedor, valores de inicio de sesión,
servicios, reenvío de eventos y RustDesk cuando estaba configurado. Se conservan
sus archivos y una copia de su tarea. No reinstala el paquete antiguo cada día.
## DNS y conectividad
En CED, `ced-network.json` define `20.9.81.130` primero y `192.168.54.211` como
respaldo, tanto para el adaptador como para NRPT. Solo AF/SD/SI de CED reciben
la modificación del adaptador Wi-Fi. El extremo público de SGU-DC01 y el nombre
del dominio se mantienen en un bloque administrado de `hosts`; los alias de
broker y RustDesk existentes se conservan. Una entrada manual contradictoria
provoca un error para revisión, sin sobrescribirla.
Una red de emergencia elegida manualmente conserva sus DNS por DHCP y no se
fuerza una desconexión. NRPT mantiene la resolución del dominio. Esa resolución
y el acceso a AD dependen de que el extremo permita la red de salida utilizada.
El orden de DNS expresa preferencia; Active Directory todavía puede elegir
otro controlador mediante DC Locator y sus sitios. No se altera la replicación
privada de los controladores.
## Aplicación a clientes
Con conexión al dominio y canal seguro sano, ejecutar como administrador:
```powershell
Test-ComputerSecureChannel -Server SGU-DC01.lci.lasalle.mx
gpupdate.exe /target:computer /force
```
Después reiniciar para procesar los scripts de arranque. No volver a enrolar
una estación que ya tiene el canal seguro sano. Los equipos desconectados
reciben la configuración cuando vuelven a comunicarse con el dominio.
Estado Wi-Fi sin claves:
`C:\ProgramData\LCI-Admin\CED-WiFi\machine-wifi-status.json`.
Respaldos de tareas retiradas:
`C:\ProgramData\LCI-Admin\PolicyConsolidation\*.before.xml`.
## Publicación y reversión
En el principal, con permisos administrativos, conservar una copia nativa de
las GPO mediante `Backup-GPO`. Ejecutar desde el conjunto completo de scripts:
```powershell
.\Merge-SguClientPolicies.ps1 -WhatIf
.\Merge-SguClientPolicies.ps1
```
Este comando consolida GPO existentes con identificadores conocidos del
laboratorio; no crea un bosque. Verifica el esquema de las tareas con Windows,
actualiza las versiones de AD y SYSVOL solo al cambiar archivos, y conserva el
paquete y SHA-256 previamente fijados para el proveedor.
Para revertir, restaurar individualmente las GPO modificadas desde su BackupId,
actualizar políticas y reiniciar. Las tareas antiguas deshabilitadas pueden
habilitarse con `Enable-ScheduledTask`; antes de restaurar el guardián, retirar
`ProviderManagedByGpo` de
`HKLM:\SOFTWARE\Policies\LaSalle\ClientMaintenance`. El cambio de hosts tiene
copia en `C:\ProgramData\LCI-Admin\CED-WiFi\hosts.before-consolidation`.
Restaurar archivos de una estación usando exclusivamente su propia copia.
Se conservan los lectores de permisos Wi-Fi, el mantenimiento DNS de Sala
Inmersiva, el procesamiento de altas Linux de RustDesk y la selección de origen
privado de DC02: atienden funciones vigentes. No se cambia su frecuencia sin
reemplazar esas funciones. Los fondos, restricciones de navegación, perfiles,
servicios y cuentas existentes permanecen bajo sus políticas actuales.
+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.
+25
View File
@@ -0,0 +1,25 @@
# v0.6.23 — Consolidación de políticas
Unifica el mantenimiento del laboratorio conservando la configuración útil:
- DNS del adaptador y NRPT de CED prefieren SGU-DC01; DC02 queda como respaldo.
Una única configuración compartida evita que los auxiliares se contradigan.
- Wi-Fi de equipo antes de iniciar sesión y después de cerrarla, con recuperación
por eventos y selección manual de una red de emergencia.
- Una GPO mantiene el acceso remoto. El enrolamiento ConfigMgr antiguo de CED
deja de instalarse desde la GPO Wi-Fi.
- Las tareas de instalación ConfigMgr y SCOM pasan de cada 30 minutos a eventos
de registro por GPO, arranque y conexión de red. Conservan versiones objetivo,
configuración y dos reintentos limitados ante fallos.
- El guardián antiguo del proveedor se retira después de comprobar los servicios
y la configuración que lo sustituyen; sus archivos y tareas quedan respaldados.
- El inventario auxiliar de Azure pasa de cinco minutos a una hora; se conservan
SCOM, la retención de eventos, las políticas visuales y las de navegación.
`Merge-SguClientPolicies.ps1` actualiza el dominio existente. No ejecute el
bootstrap de creación de bosque para aplicar esta consolidación. Consulte
`policy-consolidation.md` para responsables, aplicación, límites y reversión.
La consolidación de GPO conserva el paquete y SHA-256 del proveedor ya fijados
en el dominio. Esta versión cambia los scripts de mantenimiento, sin modificar
el código de autenticación del proveedor.
+29
View File
@@ -0,0 +1,29 @@
# v0.6.24 — Consolidación de políticas
Unifica el mantenimiento del laboratorio conservando la configuración útil:
- DNS del adaptador y NRPT de CED prefieren SGU-DC01; DC02 queda como respaldo.
Una única configuración compartida evita que los auxiliares se contradigan.
- Wi-Fi de equipo antes de iniciar sesión y después de cerrarla, con recuperación
por eventos y selección manual de una red de emergencia.
- Una GPO mantiene el acceso remoto. El enrolamiento ConfigMgr antiguo de CED
deja de instalarse desde la GPO Wi-Fi.
- Las tareas de instalación ConfigMgr y SCOM pasan de cada 30 minutos a eventos
de registro por GPO, arranque y conexión de red. Conservan versiones objetivo,
configuración y dos reintentos limitados ante fallos.
- El guardián antiguo del proveedor se retira después de comprobar los servicios
y la configuración que lo sustituyen; sus archivos y tareas quedan respaldados.
- El inventario auxiliar de Azure pasa de cinco minutos a una hora; se conservan
SCOM, la retención de eventos, las políticas visuales y las de navegación.
`Merge-SguClientPolicies.ps1` actualiza el dominio existente. No ejecute el
bootstrap de creación de bosque para aplicar esta consolidación. Consulte
`policy-consolidation.md` para responsables, aplicación, límites y reversión.
La consolidación de GPO conserva el paquete y SHA-256 del proveedor ya fijados
en el dominio. Esta versión cambia los scripts de mantenimiento, sin modificar
el código de autenticación del proveedor.
Corrige además la recuperación inicial del perfil WLAN cuando el equipo todavía
no tiene una copia local: LDAP usa la identidad de la cuenta de equipo con firma
y cifrado. Verificado como SYSTEM en una estación real contra SGU-DC01.
+30 -5
View File
@@ -18,6 +18,19 @@ the same source list. RDP uses a separate allowlist. See
`Marshal.ZeroFreeGlobalAllocUnicode`; managed references are released as soon
as each request completes.
- The broker uses the exact received value for both NTLM and AD `SetPassword`.
- The `SGU - Institutional password authority` fine-grained AD password policy
applies only to the global security groups `SGU-Alumnos`,
`SGU-Administrativos`, and `SGU-Docentes`. It disables AD complexity,
history, and password age requirements and permits passwords from one
character onward so 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`
extended right. Only an administrator or the broker through the separate
`Reset Password` right can replace the AD password.
@@ -89,13 +102,25 @@ Use an enterprise CA with revocation checking in production.
The provider distinguishes an SGU rejection from unavailable infrastructure:
- `400`/`401`: do not create or update the account; submit the unchanged
credential to Windows so an existing AD account can authenticate.
- `400`/`401`: do not create or update the account and do not submit a Windows
credential. An explicit SGU rejection is authoritative, including when an
older AD password still exists.
- `DIRECTORY_SYNCHRONIZATION_FAILED`: SGU accepted the password but AD did not
record it. Show a specific error and do not attempt Windows logon against a
potentially stale AD verifier.
- timeout, TLS/connectivity error, `429`, or `5xx`: submit the unchanged
credential to Windows. Windows must still validate it against AD or its cached
domain verifier, so this does not grant access without a domain credential.
credential to Windows only for a genuine broker/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.
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
password verifier duplicates attackable credential material, while a reversible
+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
$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')) {
$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) {
if (-not $managedUser.CannotChangePassword) {
Set-ADAccountControl -Identity $managedUser.DistinguishedName `
-CannotChangePassword $true -Server $LdapHost -Confirm:$false
$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,
@{ 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 -and $env:COMPUTERNAME -notmatch '^(AF|SD|SI)-') {
$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'
1203 = 'ProfileEnrichmentFailure'
1204 = 'ProfilePageUnavailable'
1205 = 'ProfilePhotoUnavailable'
1206 = 'ProfilePhotoInvalid'
1300 = 'DirectorySynchronizationFailure'
1301 = 'DirectoryOptionalMetadataFailure'
1302 = 'DirectoryGroupMembershipFailure'
1303 = 'DirectoryRoleGroupMembershipAdded'
1304 = 'DirectoryPasswordChangeDenied'
1305 = 'DirectoryPhotoFailure'
1306 = 'DirectoryReversiblePasswordEncryptionEnabled'
1307 = 'DirectoryReversiblePasswordEncryptionDisabled'
}
# 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 'New-LabCertificate.ps1'),
(Join-Path $scriptsRoot 'Set-LabBrokerDns.ps1'),
(Join-Path $scriptsRoot 'Set-SguInstitutionalPasswordPolicy.ps1'),
(Join-Path $scriptsRoot 'Set-SguDomainComputerPolicies.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationRemoteAccess.ps1'),
(Join-Path $scriptsRoot 'Enable-SguWorkstationAdministrators.ps1'),
(Join-Path $scriptsRoot 'Install-SguWorkstationRemoteAccessPolicy.ps1'),
(Join-Path $scriptsRoot 'Install-SguDomainRemoteManagementPolicy.ps1'),
(Join-Path $scriptsRoot 'Set-SguDomainUserPolicies.ps1'),
(Join-Path $scriptsRoot 'Set-SguLaboratorioWallpaperPolicy.ps1'),
(Join-Path $scriptsRoot 'Enable-SguServerRemoteManagement.ps1'),
@@ -771,6 +776,9 @@ if (Test-Path -LiteralPath $brokerConfigurationPath -PathType Leaf) {
-CreateMissingOus `
-DisableCertificateRevocationCheckForLab | Out-Null
& (Join-Path $scriptsRoot 'Set-SguInstitutionalPasswordPolicy.ps1') `
-BaseDn $baseDn -DomainController $adServer | Out-Null
# Remove stale A records registered by any non-domain/NAT adapter before its
# dynamic DNS registration was disabled.
$hostRecords = @(Get-DnsServerResourceRecord -ZoneName $DomainName `
@@ -820,6 +828,12 @@ $collectorFqdn = "$env:COMPUTERNAME.$DomainName"
-TargetOuDn $laboratoryOuDn `
-DomainController $env:COMPUTERNAME `
-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') `
-CollectorFqdn $collectorFqdn `
-ComputerOuDn $laboratoryOuDn `
+78
View File
@@ -0,0 +1,78 @@
[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}
foreach($name in 'ced-network.json','Set-SguCedClientNetwork.ps1'){
$source=Join-Path $PSScriptRoot $name
$target=Join-Path $destination $name
if($source -ine $target -and (-not(Test-Path -LiteralPath $target) -or (Get-FileHash -LiteralPath $source).Hash -ne (Get-FileHash -LiteralPath $target).Hash)){Copy-Item -LiteralPath $source -Destination $target -Force}
}
$networkConfiguration=[IO.File]::ReadAllText((Join-Path $destination 'ced-network.json'))|ConvertFrom-Json
$primaryDomainController=[string]$networkConfiguration.PrimaryController
& (Join-Path $destination 'Set-SguCedClientNetwork.ps1')|Out-Null
$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;$found=$null
try{
# The managed hosts entry directs this FQDN to the Azure public endpoint of
# the primary DC; the signed and sealed machine binding protects the read.
$domainDn=($computer.Domain.Split('.')|ForEach-Object{'DC='+$_}) -join ','
$authentication=[DirectoryServices.AuthenticationTypes]::Secure -bor [DirectoryServices.AuthenticationTypes]::Signing -bor [DirectoryServices.AuthenticationTypes]::Sealing
# PowerShell converts null string constructor arguments to empty credentials.
# The path-only constructor retains the scheduled task's computer identity.
$searchRoot=[DirectoryServices.DirectoryEntry]::new("LDAP://$primaryDomainController/CN=Policies,CN=System,"+$domainDn)
$searchRoot.psbase.AuthenticationType=$authentication
$searcher=[DirectoryServices.DirectorySearcher]::new($searchRoot)
$searcher.ClientTimeout=[TimeSpan]::FromSeconds(10)
$searcher.ServerTimeLimit=[TimeSpan]::FromSeconds(10)
$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($found){$found.Dispose()};if($searcher){$searcher.Dispose()};if($searchRoot){$searchRoot.psbase.Dispose()};$profile=$null;$policy=$null}
}
if(-not $profileState.MachineProfileReady){throw 'Machine Wi-Fi profile is not ready.'}
$profileState
@@ -1,12 +1,12 @@
[CmdletBinding(SupportsShouldProcess)]
param(
[string]$Version = '0.6.16',
[string]$Version = '0.6.21',
[ValidatePattern('^https://')]
[string]$ClientPackageUri = 'https://gitea.lci.ulsa.mx/alexrg/SGU-CredentialProvider/releases/download/v0.6.16/sgu-windows-client-bootstrap-0.6.16.zip',
[string]$ClientPackageUri = 'https://gitea.lci.ulsa.mx/alexrg/SGU-CredentialProvider/releases/download/v0.6.21/sgu-windows-client-bootstrap-0.6.21.zip',
[ValidatePattern('^[0-9A-Fa-f]{64}$')]
[string]$ClientPackageSha256 = 'AFC40A87E83A6B27319792F575C384EBB175F42DCF670B7AB620A64C75ED499B',
[string]$ClientPackageSha256 = '59E2ECCB16A951D5A55D005325B734501868BFB2CFCFEF507A0FE8A1F829C21E',
[string]$GpoName = 'SGU - Credential Provider update',
@@ -23,6 +23,11 @@ if (-not $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administra
Import-Module ActiveDirectory -ErrorAction Stop
Import-Module GroupPolicy -ErrorAction Stop
if ($env:COMPUTERNAME -ine $DomainController.Split('.')[0]) {
throw 'Publish on the specified domain controller to keep AD and SYSVOL consistent.'
}
$consolidationSource = Join-Path $PSScriptRoot 'Invoke-SguWorkstationConsolidation.ps1'
if (-not (Test-Path -LiteralPath $consolidationSource)) { throw 'Invoke-SguWorkstationConsolidation.ps1 is required.' }
$domain = Get-ADDomain -Server $DomainController -ErrorAction Stop
$domainDnsRoot = $domain.DNSRoot
@@ -79,12 +84,15 @@ if (-not `$computerSystem.PartOfDomain -or `$computerSystem.DomainRole -ge 4) {
# 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}'
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) {
`$registered = Get-Item 'HKLM:\SOFTWARE\Classes\CLSID\{D789CFD8-5AD4-489F-9B83-7EB5D9D09335}\InprocServer32' -ErrorAction SilentlyContinue
`$display = Get-Item 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Authentication\Credential Providers\{D789CFD8-5AD4-489F-9B83-7EB5D9D09335}' -ErrorAction SilentlyContinue
`$providerHealthy = `$registered -and (Test-Path -LiteralPath `$registered.GetValue('')) -and `$display -and `$display.GetValue('') -eq 'Acceso Institucional'
if ((Test-Path -LiteralPath `$markerPath -PathType Leaf) -and `$providerHealthy) {
& (Join-Path `$PSScriptRoot 'Invoke-SguWorkstationConsolidation.ps1') | Out-Null
exit 0
}
@@ -140,10 +148,12 @@ if (-not `$runtimeInstalled) {
& `$installScript @installParameters | Out-Null
[IO.File]::WriteAllText(`$markerPath, (Get-Date).ToUniversalTime().ToString('o'), [Text.UTF8Encoding]::new(`$false))
& (Join-Path `$PSScriptRoot 'Invoke-SguWorkstationConsolidation.ps1') | Out-Null
"@
if ($PSCmdlet.ShouldProcess($startupPath, "Install '$scriptName' as a computer startup script")) {
New-Item -ItemType Directory -Path $startupPath -Force | Out-Null
Copy-Item -LiteralPath $consolidationSource -Destination (Join-Path $startupPath 'Invoke-SguWorkstationConsolidation.ps1') -Force
[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"
+3 -1
View File
@@ -4,6 +4,8 @@ param(
[string]$CollectorFqdn = "$env:COMPUTERNAME.$env:USERDNSDOMAIN",
[string]$ComputerOuDn = 'OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$MonitoringRoot = 'C:\ProgramData\SGU\Monitoring',
[ValidateRange(5,1440)]
[int]$InventoryIntervalMinutes = 60,
[ValidateRange(30, 730)]
[int]$RetentionDays = 183
)
@@ -114,7 +116,7 @@ if ($PSCmdlet.ShouldProcess($env:COMPUTERNAME, 'Install the SGU domain monitorin
"-NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$maintenanceScript`" " +
"-MonitoringRoot `"$MonitoringRoot`" -ComputerOuDn `"$ComputerOuDn`" -RetentionDays $RetentionDays -InventoryOnly")
$inventoryTrigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(1) `
-RepetitionInterval (New-TimeSpan -Minutes 5) `
-RepetitionInterval (New-TimeSpan -Minutes $InventoryIntervalMinutes) `
-RepetitionDuration (New-TimeSpan -Days 3650)
$taskSettings = New-ScheduledTaskSettingsSet -StartWhenAvailable `
-ExecutionTimeLimit (New-TimeSpan -Minutes 10) -RestartCount 2 `
@@ -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())}
+3
View File
@@ -25,6 +25,9 @@ param(
)
$ErrorActionPreference = 'Stop'
if ((Get-ItemProperty 'HKLM:\SOFTWARE\Policies\LaSalle\ClientMaintenance' -Name ProviderManagedByGpo -ErrorAction SilentlyContinue).ProviderManagedByGpo -eq 1) {
return
}
$taskName = 'SGU-CredentialProvider-EnrollmentGuard'
$enrollmentRoot = Join-Path $env:ProgramData 'SGU\Enrollment'
$sourceScripts = @(
@@ -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
}
+17
View File
@@ -0,0 +1,17 @@
[CmdletBinding()]
param([switch]$InstallTask)
$ErrorActionPreference='Stop'
# Compatibility entry point for cached WLAN startup registrations.
# The global SYSTEMCENTER GPO owns installation, repair and version selection.
$canonical=Get-ScheduledTask -TaskName 'LCI-ConfigMgr2509-ClientRegistration' -ErrorAction SilentlyContinue
if(-not $canonical -or -not $canonical.Settings.Enabled -or $canonical.Actions.Arguments -notmatch 'SYSTEMCENTER\.lci\.lasalle\.mx.+Ensure-CMCurrentClient\.ps1'){
Write-Warning 'Apply the global Configuration Manager policy with gpupdate /target:computer /force. The retired CED installer task is not recreated.'
return
}
foreach($name in 'CED Configuration Manager enrollment','CED Configuration Manager policy enrollment'){
$old=Get-ScheduledTask -TaskName $name -ErrorAction SilentlyContinue
if($old -and $old.Settings.Enabled -and $old.State -ne 'Running'){Disable-ScheduledTask -InputObject $old|Out-Null}
}
if($InstallTask -and -not(Get-Service CcmExec -ErrorAction SilentlyContinue)){
Start-ScheduledTask -InputObject $canonical
}
+87
View File
@@ -0,0 +1,87 @@
[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 = '',
[string]$FallbackDnsServer = '',
[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
$networkConfiguration=[IO.File]::ReadAllText((Join-Path $PSScriptRoot 'ced-network.json'))|ConvertFrom-Json
if(-not $DnsServer){$DnsServer=[string]$networkConfiguration.DnsServers[0]}
if(-not $FallbackDnsServer){$FallbackDnsServer=[string]$networkConfiguration.DnsServers[1]}
$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) {
Invoke-Command -Session $session {
$task=Get-ScheduledTask -TaskName 'LCI-ConfigMgr2509-ClientRegistration' -ErrorAction SilentlyContinue
if(-not $task -or -not $task.Settings.Enabled){throw 'Apply the global SYSTEMCENTER Configuration Manager GPO before requesting client installation.'}
Start-ScheduledTask -InputObject $task
}
}
if ($MigrateWifi) {
foreach ($file in 'Install-SguCedWifiMaintenance.ps1','Repair-SguCedWifi.ps1','Set-SguCedClientNetwork.ps1','ced-network.json') {
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 }
}
}
@@ -0,0 +1,57 @@
# Called by the existing provider-update GPO, after its verified installer.
[CmdletBinding()]
param()
$ErrorActionPreference = 'Stop'
$computer = Get-CimInstance Win32_ComputerSystem
if (-not $computer.PartOfDomain -or $computer.DomainRole -ne 1) { return }
$id = '{D789CFD8-5AD4-489F-9B83-7EB5D9D09335}'
$provider = Get-Item "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Authentication\Credential Providers\$id" -ErrorAction SilentlyContinue
$com = Get-Item "HKLM:\SOFTWARE\Classes\CLSID\$id\InprocServer32" -ErrorAction SilentlyContinue
$default = (Get-ItemProperty 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\System' -Name DefaultCredentialProvider -ErrorAction SilentlyContinue).DefaultCredentialProvider
$services = @(Get-Service WinRM,TermService -ErrorAction SilentlyContinue)
$ready = $provider -and $provider.GetValue('') -eq 'Acceso Institucional' -and $com -and $com.GetValue('') -and
(Test-Path -LiteralPath $com.GetValue('')) -and $default -eq $id -and
(Test-Path "$env:ProgramData\SGU\CredentialProvider\settings.json") -and
$services.Count -eq 2 -and @($services | Where-Object Status -ne Running).Count -eq 0
$root = Join-Path $env:ProgramData 'LCI-Admin\PolicyConsolidation'
$changed = [Collections.Generic.List[string]]::new()
function Disable-OwnedTask([string]$Name) {
$task = Get-ScheduledTask -TaskPath '\' -TaskName $Name -ErrorAction SilentlyContinue
if (-not $task -or -not $task.Settings.Enabled) { return }
# Preserve XML and installed files. Never interrupt an installation in flight.
if ($task.State -eq 'Running') { Write-Warning "Retirement deferred while $Name runs."; return }
if (-not (Test-Path -LiteralPath $root)) { New-Item $root -ItemType Directory -Force | Out-Null }
$backup = Join-Path $root ($Name+'.before.xml')
if (-not (Test-Path -LiteralPath $backup)) { Export-ScheduledTask -InputObject $task | Set-Content -LiteralPath $backup -Encoding Unicode }
Disable-ScheduledTask -InputObject $task | Out-Null
$changed.Add($Name)
}
if ($ready) {
# Preserve the enrollment guard until its other features are present.
$enrollmentPath = Join-Path $env:ProgramData 'SGU\Enrollment\enrollment.json'
$rustDeskReady = $true
if (Test-Path -LiteralPath $enrollmentPath) {
$enrollment = [IO.File]::ReadAllText($enrollmentPath) | ConvertFrom-Json
if ($enrollment.RustDeskServerAddress) { $rustDeskReady = (Get-Service RustDesk -ErrorAction SilentlyContinue).Status -eq 'Running' }
}
$forwardingReady = Test-Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager'
if ($rustDeskReady -and $forwardingReady) {
Disable-OwnedTask 'SGU-CredentialProvider-EnrollmentGuard'
$guard = Get-ScheduledTask -TaskName 'SGU-CredentialProvider-EnrollmentGuard' -ErrorAction SilentlyContinue
if (-not $guard -or -not $guard.Settings.Enabled) {
$key = 'HKLM:\SOFTWARE\Policies\LaSalle\ClientMaintenance'
if (-not (Test-Path $key)) { New-Item $key -Force | Out-Null }
if ((Get-ItemProperty $key -Name ProviderManagedByGpo -ErrorAction SilentlyContinue).ProviderManagedByGpo -ne 1) {
New-ItemProperty $key -Name ProviderManagedByGpo -Value 1 -PropertyType DWord -Force | Out-Null
}
}
}
}
# The global SYSTEMCENTER GPO owns installation/repair from now on.
$canonical = Get-ScheduledTask -TaskName 'LCI-ConfigMgr2509-ClientRegistration' -ErrorAction SilentlyContinue
if ($canonical -and $canonical.Settings.Enabled -and $canonical.Actions.Arguments -match 'SYSTEMCENTER\.lci\.lasalle\.mx.+Ensure-CMCurrentClient\.ps1') {
Disable-OwnedTask 'CED Configuration Manager enrollment'
Disable-OwnedTask 'CED Configuration Manager policy enrollment'
}
if ((Get-Service HealthService -ErrorAction SilentlyContinue).Status -eq 'Running') { Disable-OwnedTask 'LCI-SCOM-AgentInstallNow' }
[pscustomobject]@{Computer=$env:COMPUTERNAME;ProviderReady=[bool]$ready;Disabled=@($changed.ToArray())}
+135
View File
@@ -0,0 +1,135 @@
#Requires -Version 5.1
[CmdletBinding(SupportsShouldProcess)]
param([string]$DomainController = 'SGU-DC01.lci.lasalle.mx')
$ErrorActionPreference = 'Stop'
if ($env:COMPUTERNAME -ine $DomainController.Split('.')[0]) { throw 'Run on the specified primary DC so AD and SYSVOL are updated together.' }
Import-Module ActiveDirectory
Import-Module GroupPolicy
$domain = Get-ADDomain -Server $DomainController
$dn = $domain.DistinguishedName
$changes = [Collections.Generic.List[string]]::new()
$modified = @{}
$ids = @{
Wifi='0f62e905-dacb-4721-9f02-2e21423bb82e'
Provider='3b13538e-f7bf-4c26-9dd1-bf261a3378ae'
Remote='dddd0dcb-95f2-420a-bfbb-2e179c414ae4'
Experience='6332a4e0-2b6d-4b4c-8d88-0a758ba17fb3'
ConfigMgr='d882e45d-5e11-4460-98a3-d9ddc6d04bf3'
Scom='3437c619-254f-4afe-bbd5-5cbe23116c5d'
}
$roots = @{}
foreach ($key in $ids.Keys) {
Get-GPO -Guid $ids[$key] -Domain $domain.DNSRoot -Server $DomainController | Out-Null
$roots[$key] = Join-Path $env:WINDIR ("SYSVOL\domain\Policies\{"+$ids[$key]+'}')
}
function Set-PolicyText([string]$Owner,[string]$Relative,[string]$Text,[Text.Encoding]$Encoding=[Text.UTF8Encoding]::new($false)) {
$path = Join-Path $roots[$Owner] $Relative
if ((Test-Path -LiteralPath $path) -and [IO.File]::ReadAllText($path) -ceq $Text) { return }
if ($PSCmdlet.ShouldProcess($path,'Update consolidated policy file')) {
[IO.Directory]::CreateDirectory((Split-Path $path)) | Out-Null
[IO.File]::WriteAllText($path,$Text,$Encoding)
$modified[$Owner]=$true
$changes.Add("$Owner : $Relative")
}
}
foreach ($file in 'Install-SguCedWifiMaintenance.ps1','Repair-SguCedWifi.ps1','Set-SguCedClientNetwork.ps1','ced-network.json','Invoke-SguCedClientEnrollment.ps1') {
Set-PolicyText Wifi ('Machine\Scripts\Startup\'+$file) ([IO.File]::ReadAllText((Join-Path $PSScriptRoot $file)))
}
$wifiScript = "\\$($domain.DNSRoot)\SYSVOL\$($domain.DNSRoot)\Policies\{$($ids.Wifi)}\Machine\Scripts\Startup\Install-SguCedWifiMaintenance.ps1"
Set-PolicyText Wifi 'Machine\Scripts\scripts.ini' ("[Startup]`r`n0CmdLine=powershell.exe`r`n0Parameters=-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$wifiScript`"`r`n") ([Text.Encoding]::Unicode)
# Keep the administrators helper and all UI/branding values in this GPO;
# remote-access configuration belongs exclusively to the domain-wide GPO.
$experienceIni = [IO.File]::ReadAllText((Join-Path $roots.Experience 'Machine\Scripts\scripts.ini'))
$startupSection = [regex]::Match($experienceIni,'(?ms)^\[Startup\]\r?\n(?<Body>.*?)(?=^\[|\z)')
if (-not $startupSection.Success) { throw 'Missing workstation-experience Startup section.' }
$entries = @([regex]::Matches($startupSection.Groups['Body'].Value,'(?m)^(\d+)CmdLine=(.*)\r?\n\1Parameters=(.*)\r?$'))
if (-not $entries.Count) { throw 'Unexpected workstation-experience startup registration.' }
$ini = "[Startup]`r`n"; $index=0
foreach ($entry in $entries) {
if ($entry.Groups[3].Value -match 'Enable-SguWorkstationRemoteAccess\.ps1') { continue }
$ini += "$($index)CmdLine=$($entry.Groups[2].Value.TrimEnd())`r`n$($index)Parameters=$($entry.Groups[3].Value.TrimEnd())`r`n"
$index++
}
$experienceUpdated = $experienceIni.Remove($startupSection.Index,$startupSection.Length).Insert($startupSection.Index,$ini)
Set-PolicyText Experience 'Machine\Scripts\scripts.ini' $experienceUpdated ([Text.Encoding]::Unicode)
$remoteIni = [IO.File]::ReadAllText((Join-Path $roots.Remote 'Machine\Scripts\scripts.ini'))
$remoteIni = $remoteIni -replace ' -LocalDnsServer [^\s]+','' -replace ' -FallbackDnsServer [^\s]+',''
Set-PolicyText Remote 'Machine\Scripts\scripts.ini' $remoteIni ([Text.Encoding]::Unicode)
Set-PolicyText Remote 'Machine\Scripts\Startup\Enable-SguWorkstationRemoteAccess.ps1' ([IO.File]::ReadAllText((Join-Path $PSScriptRoot 'Enable-SguWorkstationRemoteAccess.ps1')))
$providerIni = [IO.File]::ReadAllText((Join-Path $roots.Provider 'Machine\Scripts\scripts.ini'))
$match = [regex]::Match($providerIni,'Update-SguCredentialProvider-[0-9.]+\.ps1')
if (-not $match.Success) { throw 'Expected one existing verified provider updater.' }
$providerRelative = 'Machine\Scripts\Startup\'+$match.Value
$updater = [IO.File]::ReadAllText((Join-Path $roots.Provider $providerRelative))
$retirement = '& (Join-Path $PSScriptRoot ''Invoke-SguWorkstationConsolidation.ps1'') | Out-Null'
if ($updater -notmatch 'Invoke-SguWorkstationConsolidation') {
# Reuse the already pinned package/hash, certificates and version. A marker
# alone must not hide a missing COM binary or an obsolete display name.
$old = 'if (Test-Path -LiteralPath $markerPath -PathType Leaf) {'
$new = @'
$providerId = '{D789CFD8-5AD4-489F-9B83-7EB5D9D09335}'
$registered = Get-Item "HKLM:\SOFTWARE\Classes\CLSID\$providerId\InprocServer32" -ErrorAction SilentlyContinue
$display = Get-Item "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Authentication\Credential Providers\$providerId" -ErrorAction SilentlyContinue
$providerHealthy = $registered -and (Test-Path -LiteralPath $registered.GetValue('')) -and $display -and $display.GetValue('') -eq 'Acceso Institucional'
if ((Test-Path -LiteralPath $markerPath -PathType Leaf) -and $providerHealthy) {
& (Join-Path $PSScriptRoot 'Invoke-SguWorkstationConsolidation.ps1') | Out-Null
'@
if (-not $updater.Contains($old)) { throw 'Provider updater layout changed; inspect before merging.' }
$updater = $updater.Replace($old,$new)+"`r`n$retirement`r`n"
}
Set-PolicyText Provider $providerRelative $updater
Set-PolicyText Provider 'Machine\Scripts\Startup\Invoke-SguWorkstationConsolidation.ps1' ([IO.File]::ReadAllText((Join-Path $PSScriptRoot 'Invoke-SguWorkstationConsolidation.ps1')))
foreach ($owner in 'ConfigMgr','Scom') {
$relative = 'Machine\Preferences\ScheduledTasks\ScheduledTasks.xml'
[xml]$xml = [IO.File]::ReadAllText((Join-Path $roots[$owner] $relative))
$task = $xml.SelectSingleNode('//*[local-name()="Task"]')
$triggers = $task.SelectSingleNode('*[local-name()="Triggers"]')
if (-not $triggers -or $task.SelectSingleNode('.//*[local-name()="Arguments"]').InnerText -notmatch 'SYSTEMCENTER\.lci\.lasalle\.mx') { throw 'Unexpected agent deployment policy.' }
foreach ($time in @($triggers.SelectNodes('*[local-name()="TimeTrigger"]'))) { [void]$triggers.RemoveChild($time) }
if (-not $triggers.SelectSingleNode('*[local-name()="EventTrigger"]')) {
$event = $xml.CreateElement('EventTrigger',$task.NamespaceURI)
$enabled=$xml.CreateElement('Enabled',$task.NamespaceURI);$enabled.InnerText='true';[void]$event.AppendChild($enabled)
$subscription=$xml.CreateElement('Subscription',$task.NamespaceURI)
$subscription.InnerText='<QueryList><Query Id="0" Path="Microsoft-Windows-NetworkProfile/Operational"><Select Path="Microsoft-Windows-NetworkProfile/Operational">*[System[EventID=10000]]</Select></Query></QueryList>'
[void]$event.AppendChild($subscription)
$delay=$xml.CreateElement('Delay',$task.NamespaceURI);$delay.InnerText='PT1M';[void]$event.AppendChild($delay)
[void]$triggers.AppendChild($event)
}
$settings=$task.SelectSingleNode('*[local-name()="Settings"]')
if (-not $settings.SelectSingleNode('*[local-name()="RestartOnFailure"]')) {
$restart=$xml.CreateElement('RestartOnFailure',$task.NamespaceURI)
foreach ($pair in @(@('Interval','PT5M'),@('Count','2'))) {$child=$xml.CreateElement($pair[0],$task.NamespaceURI);$child.InnerText=$pair[1];[void]$restart.AppendChild($child)}
[void]$settings.AppendChild($restart)
}
# Ask Windows to validate the actual task schema before writing the GPP.
# TASK_VALIDATE_ONLY (1) never registers or launches a task.
$scheduler=New-Object -ComObject Schedule.Service
$scheduler.Connect()
[void]$scheduler.GetFolder('\').RegisterTask('LCI-Consolidation-SchemaValidation',$task.OuterXml,1,'SYSTEM',$null,5,$null)
Set-PolicyText $owner $relative $xml.OuterXml
}
foreach ($owner in @($modified.Keys)) {
$gpoDn="CN={$($ids[$owner])},CN=Policies,CN=System,$dn"
$ad=Get-ADObject $gpoDn -Server $DomainController -Properties versionNumber
$gpt=Join-Path $roots[$owner] 'GPT.INI'
$text=[IO.File]::ReadAllText($gpt)
$gptVersion=[long]([regex]::Match($text,'(?m)^Version=(\d+)\r?$').Groups[1].Value)
$base=[Math]::Max([long]$ad.versionNumber,$gptVersion)
$version=($base -band 0xFFFF0000L) -bor (($base+1) -band 0xFFFFL)
[IO.File]::WriteAllText($gpt,([regex]::Replace($text,'(?m)^Version=\d+\r?$',"Version=$version")),[Text.Encoding]::ASCII)
Set-ADObject $gpoDn -Server $DomainController -Replace @{versionNumber=[int]$version}
}
if ($PSCmdlet.ShouldProcess('CED - DNS de dominio','Align domain NRPT with the shared CED network configuration')) {
& (Join-Path $PSScriptRoot 'Set-SguCedDnsPolicy.ps1') -DomainController $DomainController | Out-Null
}
$configurationKey='HKLM\Software\Policies\LaSalle\CEDWifi'
$currentConfiguration=Get-GPRegistryValue -Guid $ids.Wifi -Domain $domain.DNSRoot -Server $DomainController -Key $configurationKey -ValueName ConfigurationVersion -ErrorAction SilentlyContinue
if ((-not $currentConfiguration -or $currentConfiguration.Value -ne 4) -and $PSCmdlet.ShouldProcess('CED - Wi-Fi de salas','Set configuration version 4')) {
Set-GPRegistryValue -Guid $ids.Wifi -Domain $domain.DNSRoot -Server $DomainController -Key $configurationKey -ValueName ConfigurationVersion -Type DWord -Value 4 | Out-Null
$changes.Add('Wifi : ConfigurationVersion=4')
}
[pscustomobject]@{Changed=($changes.Count -gt 0);Files=@($changes.ToArray());Gpos=@($modified.Keys);PrimaryController=$DomainController}
+54 -4
View File
@@ -91,20 +91,22 @@ $clientRoot = Join-Path $resolvedOutputRoot "sgu-windows-client-bootstrap-$Versi
$serverRoot = Join-Path $resolvedOutputRoot "sgu-server-bootstrap-$Version"
$linuxClientRoot = Join-Path $resolvedOutputRoot "sgu-linux-client-bootstrap-$Version"
$azureRoot = Join-Path $resolvedOutputRoot "sgu-azure-infrastructure-$Version"
$wifiRoot = Join-Path $resolvedOutputRoot "sgu-ced-wifi-policy-$Version"
$clientZip = "$clientRoot.zip"
$serverZip = "$serverRoot.zip"
$linuxClientZip = "$linuxClientRoot.zip"
$azureZip = "$azureRoot.zip"
$wifiZip = "$wifiRoot.zip"
foreach ($target in @(
$clientRoot,$serverRoot,$linuxClientRoot,$azureRoot,
$clientZip,$serverZip,$linuxClientZip,$azureZip)) {
$clientRoot,$serverRoot,$linuxClientRoot,$azureRoot,$wifiRoot,
$clientZip,$serverZip,$linuxClientZip,$azureZip,$wifiZip)) {
if (Test-Path -LiteralPath $target) {
throw "Release target already exists: $target"
}
}
New-Item -ItemType Directory `
-Path $clientRoot,$serverRoot,$linuxClientRoot,$azureRoot `
-Path $clientRoot,$serverRoot,$linuxClientRoot,$azureRoot,$wifiRoot `
-Force | Out-Null
$welcomeFontNames = @(
'IndivisaTextSans-Regular.otf',
@@ -206,13 +208,30 @@ Copy-RequiredFile -Source (Join-Path $PSScriptRoot 'Start-SguServerBootstrap.cmd
Copy-RequiredFile -Source (Join-Path $PSScriptRoot 'Start-SguAzureServerBootstrap.cmd') `
-Destination (Join-Path $serverRoot 'Start-SguAzureServerBootstrap.cmd')
$serverScripts = @(
'Set-SguCedWifiPolicy.ps1',
'Set-SguCedClientNetwork.ps1',
'ced-network.json',
'Set-SguCedDnsPolicy.ps1',
'Invoke-SguWorkstationConsolidation.ps1',
'Merge-SguClientPolicies.ps1',
'Install-SguCedWifiMaintenance.ps1',
'Repair-SguCedWifi.ps1',
'Sync-SguCedWifiReaders.ps1',
'Connect-SguCedWifi.ps1',
'Invoke-SguCedClientEnrollment.ps1',
'Deploy-AuthBroker.ps1',
'Disable-SguAzureUserRoaming.ps1',
'Enable-SguAzureUserRoaming.ps1',
'Enable-SguServerRemoteManagement.ps1',
'Enable-SguWorkstationRemoteAccess.ps1',
'Enable-SguWorkstationAdministrators.ps1',
'Get-SguUsageReport.ps1',
'Get-SguBrokerLog.ps1',
'Install-SguDomainMonitoring.ps1',
'Install-SguWorkstationRemoteAccessPolicy.ps1',
'Install-SguDomainRemoteManagementPolicy.ps1',
'Sync-SguWacDomainConnections.ps1',
'Get-SguWorkstationRemoteManagementStatus.ps1',
'Publish-SguFsLogixClientDeployment.ps1',
'Install-SguRustDeskClient.ps1',
'Install-SguRustDeskLinuxEnrollment.ps1',
@@ -224,6 +243,7 @@ $serverScripts = @(
'Register-SguClientCertificate.ps1',
'Register-SguRustDeskDevice.ps1',
'Set-LabBrokerDns.ps1',
'Set-SguInstitutionalPasswordPolicy.ps1',
'Set-SguDomainComputerPolicies.ps1',
'Set-SguLaboratorioWallpaperPolicy.ps1',
'Set-SguLocalProfileSecurityPolicies.ps1',
@@ -260,7 +280,7 @@ foreach ($fontName in $welcomeFontNames) {
Copy-RequiredFile -Source (Join-Path $repositoryRoot "assets\branding\fonts\$fontName") `
-Destination (Join-Path $serverContentTarget "welcome-wallpaper\fonts\$fontName")
}
foreach ($documentation in @('user-roaming.md', 'laboratorio-wallpaper-policy.md')) {
foreach ($documentation in @('user-roaming.md', 'laboratorio-wallpaper-policy.md','policy-consolidation.md')) {
Copy-RequiredFile -Source (Join-Path $repositoryRoot "docs\$documentation") `
-Destination (Join-Path $serverRoot "docs\$documentation")
}
@@ -291,11 +311,39 @@ Write-PackageManifest -PackageRoot $azureRoot -PackageVersion $Version -PackageK
Compress-Archive -Path (Join-Path $azureRoot '*') -DestinationPath $azureZip `
-CompressionLevel Optimal
# Existing domains can publish the WLAN correction without running forest setup.
foreach ($scriptName in @(
'Enable-SguWorkstationRemoteAccess.ps1',
'Set-SguCedWifiPolicy.ps1',
'Set-SguCedClientNetwork.ps1',
'ced-network.json',
'Set-SguCedDnsPolicy.ps1',
'Invoke-SguWorkstationConsolidation.ps1',
'Merge-SguClientPolicies.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')
Copy-RequiredFile -Source (Join-Path $repositoryRoot 'docs\policy-consolidation.md') `
-Destination (Join-Path $wifiRoot 'policy-consolidation.md')
Write-PackageManifest -PackageRoot $wifiRoot -PackageVersion $Version -PackageKind CedWifiPolicy
Compress-Archive -Path (Join-Path $wifiRoot '*') -DestinationPath $wifiZip `
-CompressionLevel Optimal
$checksums = @(
("{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 $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 $wifiZip -Algorithm SHA256).Hash, (Split-Path $wifiZip -Leaf))
)
$checksumsPath = Join-Path $resolvedOutputRoot "SHA256SUMS-$Version.txt"
[IO.File]::WriteAllLines($checksumsPath, $checksums, [Text.UTF8Encoding]::new($false))
@@ -310,6 +358,8 @@ $checksumsPath = Join-Path $resolvedOutputRoot "SHA256SUMS-$Version.txt"
ServerSha256 = (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash
AzureInfrastructurePackage = $azureZip
AzureInfrastructureSha256 = (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash
CedWifiPolicyPackage = $wifiZip
CedWifiPolicySha256 = (Get-FileHash -LiteralPath $wifiZip -Algorithm SHA256).Hash
Checksums = $checksumsPath
RuntimeInstaller = $runtimeInstaller.Name
}
+8 -1
View File
@@ -23,6 +23,7 @@ $assetPaths = @(
(Join-Path $ReleaseDirectory "sgu-server-bootstrap-$Version.zip"),
(Join-Path $ReleaseDirectory "sgu-linux-client-bootstrap-$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")
)
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
name = "SGU Credential Provider $Version"
body = $releaseNotes
draft = [bool]$Draft
# Keep the release private until every attachment has uploaded.
draft = $true
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]@{
Tag = $tagName
ReleaseName = $release.name
+95
View File
@@ -0,0 +1,95 @@
[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}
$network=& (Join-Path $PSScriptRoot 'Set-SguCedClientNetwork.ps1') -ConnectedInterface @($state.Interface) -ConnectedSsid @($state.Ssid)
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
+6
View File
@@ -4,6 +4,12 @@ param(
)
$ErrorActionPreference = 'Stop'
# Domain GPO owns repair once the migration has completed. Keep this check in
# the old entry point too, so a cached bootstrap cannot undo a newer package.
$consolidationKey = 'HKLM:\SOFTWARE\Policies\LaSalle\ClientMaintenance'
if ((Get-ItemProperty $consolidationKey -Name ProviderManagedByGpo -ErrorAction SilentlyContinue).ProviderManagedByGpo -eq 1) {
return
}
$configuration = Get-Content -LiteralPath $ConfigurationPath -Raw | ConvertFrom-Json
$enrollmentRoot = Split-Path $ConfigurationPath -Parent
$testScript = Join-Path $enrollmentRoot 'Test-SguClientEnrollment.ps1'
+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)
}
+68
View File
@@ -0,0 +1,68 @@
[CmdletBinding()]
param(
[string]$ConfigurationPath = (Join-Path $PSScriptRoot 'ced-network.json'),
[string[]]$ConnectedInterface = @(),
[string[]]$ConnectedSsid = @()
)
$ErrorActionPreference = 'Stop'
$configuration = [IO.File]::ReadAllText($ConfigurationPath) | ConvertFrom-Json
$computer = Get-CimInstance Win32_ComputerSystem
if (-not $computer.PartOfDomain -or $computer.DomainRole -ne 1 -or
$computer.Domain -ine $configuration.Domain -or $env:COMPUTERNAME -notmatch $configuration.ComputerPattern) { return }
if ($ConnectedInterface.Count -ne $ConnectedSsid.Count) { throw 'Interface and SSID lists differ.' }
[Net.IPAddress]::Parse($configuration.PrimaryAddress) | Out-Null
foreach ($server in $configuration.DnsServers) { [Net.IPAddress]::Parse($server) | Out-Null }
# Preserve unrelated aliases (broker/RustDesk included). Consolidate only our
# previously managed entries; an unmanaged conflicting entry requires review.
$path = Join-Path $env:WINDIR 'System32\drivers\etc\hosts'
$begin = '# LCI CED primary domain controller - begin'
$end = '# LCI CED primary domain controller - end'
$current = [IO.File]::ReadAllText($path)
$without = [regex]::Replace($current, "(?ms)^$([regex]::Escape($begin))\r?\n.*?^$([regex]::Escape($end))\r?\n?", '')
$aliases = @([string]$configuration.PrimaryController, ($configuration.PrimaryController -split '\.')[0], [string]$configuration.Domain)
$coveredAliases = @()
$lines = [Collections.Generic.List[string]]::new()
foreach ($line in ($without -split '\r?\n')) {
$parts = $line -split '#', 2
$tokens = @($parts[0].Trim() -split '\s+' | Where-Object { $_ })
if ($tokens.Count -gt 1 -and @($tokens[1..($tokens.Count-1)] | Where-Object { $_ -in $aliases }).Count) {
if ($line -match '# SGU managed direct enrollment\s*$') {
$remaining = @($tokens[1..($tokens.Count-1)] | Where-Object { $_ -notin $aliases })
if ($remaining.Count) { $lines.Add($tokens[0]+' '+($remaining -join ' ')+' # SGU managed direct enrollment') }
continue
}
if ($tokens[0] -ne $configuration.PrimaryAddress) { throw 'An unmanaged hosts entry conflicts with the primary controller. No hosts changes made.' }
$coveredAliases += @($tokens[1..($tokens.Count-1)] | Where-Object { $_ -in $aliases })
}
$lines.Add($line)
}
$prefix = ($lines -join "`r`n").TrimEnd([char[]]"`r`n")
$missingAliases = @($aliases | Where-Object { $_ -notin $coveredAliases })
$entry = $configuration.PrimaryAddress+' '+($missingAliases -join ' ')
$updated = $(if ($prefix) { $prefix+"`r`n" } else { '' })+$(if ($missingAliases.Count) { "$begin`r`n$entry`r`n$end`r`n" } else { '' })
$hostChanged = $updated -cne $current
if ($hostChanged) {
$backup = Join-Path $env:ProgramData 'LCI-Admin\CED-WiFi\hosts.before-consolidation'
if (-not (Test-Path -LiteralPath $backup)) { Copy-Item -LiteralPath $path -Destination $backup }
[IO.File]::WriteAllText($path, $updated, [Text.UTF8Encoding]::new($false))
Clear-DnsClientCache
}
$dnsChanges = 0
for ($i=0; $i -lt $ConnectedInterface.Count; $i++) {
$adapter = Get-NetAdapter | Where-Object { [guid]$_.InterfaceGuid -eq [guid]$ConnectedInterface[$i] }
if (-not $adapter -or -not $ConnectedSsid[$i]) { continue }
if ($ConnectedSsid[$i] -eq $configuration.Ssid) {
$actual = @((Get-DnsClientServerAddress -InterfaceIndex $adapter.ifIndex -AddressFamily IPv4).ServerAddresses)
if (($actual -join ',') -ne ($configuration.DnsServers -join ',')) {
Set-DnsClientServerAddress -InterfaceIndex $adapter.ifIndex -ServerAddresses $configuration.DnsServers
$dnsChanges++
}
} else {
# Emergency Wi-Fi retains DHCP DNS. The domain NRPT is owned by GPO.
$key = 'HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\'+([guid]$adapter.InterfaceGuid).ToString('B')
$manual = (Get-ItemProperty -LiteralPath $key -Name NameServer -ErrorAction SilentlyContinue).NameServer
if ($manual) { Set-DnsClientServerAddress -InterfaceIndex $adapter.ifIndex -ResetServerAddresses; $dnsChanges++ }
}
}
[pscustomobject]@{HostsChanged=$hostChanged;DnsChanges=$dnsChanges;PrimaryController=$configuration.PrimaryController;DnsServers=@($configuration.DnsServers)}
+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 }
+33
View File
@@ -0,0 +1,33 @@
[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 = @(),
[string]$DomainController = $env:COMPUTERNAME
)
$ErrorActionPreference = 'Stop'
if (-not $DnsServer.Count) {
$configuration = [IO.File]::ReadAllText((Join-Path $PSScriptRoot 'ced-network.json')) | ConvertFrom-Json
$DnsServer = @($configuration.DnsServers)
}
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 -split '[;,\s]+' | Where-Object { $_ }) -join ',') -ne ($DnsServer -join ',')) {
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}
+157
View File
@@ -0,0 +1,157 @@
[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'
if($env:COMPUTERNAME -ine $DomainController.Split('.')[0]){throw 'Publish this policy on its specified domain controller to keep AD and SYSVOL consistent.'}
foreach ($file in 'Install-SguCedWifiMaintenance.ps1','Connect-SguCedWifi.ps1','Repair-SguCedWifi.ps1','Set-SguCedClientNetwork.ps1','ced-network.json') {
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
# Either replica can run the delegated Wi-Fi reader refresh. Publishing
# from DC01 must preserve DC02's maintenance access to this one object.
foreach ($sid in @('S-1-5-18', "$($domain.DomainSID)-512", "$($forestRoot.DomainSID)-519", "$($domain.DomainSID)-516", $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','Set-SguCedClientNetwork.ps1','ced-network.json') {
$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"
$ini = "[Startup]`r`n0CmdLine=powershell.exe`r`n0Parameters=-NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$scriptPath`"`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=4}
)){
$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.'})
}
}
}
+9
View File
@@ -0,0 +1,9 @@
{
"Version": 1,
"Domain": "lci.lasalle.mx",
"ComputerPattern": "^(AF|SD|SI)-",
"Ssid": "Centro de Experiencia Digital",
"PrimaryController": "SGU-DC01.lci.lasalle.mx",
"PrimaryAddress": "20.9.81.130",
"DnsServers": ["20.9.81.130", "192.168.54.211"]
}
@@ -13,7 +13,8 @@ public sealed record InstitutionalProfile(
string? City = null,
string? State = null,
string? PostalCode = null,
InstitutionalGender? Gender = null)
InstitutionalGender? Gender = null,
byte[]? ThumbnailPhoto = null)
{
public bool HasValues =>
EmployeeNumber is not null ||
@@ -28,7 +29,8 @@ public sealed record InstitutionalProfile(
City is not null ||
State is not null ||
PostalCode is not null ||
Gender is not null;
Gender is not null ||
ThumbnailPhoto is not null;
public InstitutionalProfile Overlay(InstitutionalProfile? values) =>
values is null
@@ -47,6 +49,7 @@ public sealed record InstitutionalProfile(
City = values.City ?? City,
State = values.State ?? State,
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 ProfileEnrichmentFailure = new(1203, nameof(ProfileEnrichmentFailure));
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 DirectoryOptionalMetadataFailure = new(1301, nameof(DirectoryOptionalMetadataFailure));
internal static readonly EventId DirectoryGroupMembershipFailure = new(1302, nameof(DirectoryGroupMembershipFailure));
internal static readonly EventId DirectoryRoleGroupMembershipAdded = new(1303, nameof(DirectoryRoleGroupMembershipAdded));
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
View File
@@ -11,6 +11,7 @@
<ProjectReference Include="..\SGU.AuthBroker.Core\SGU.AuthBroker.Core.csproj" />
<PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="10.0.11" />
<PackageReference Include="System.DirectoryServices" Version="10.0.11" />
<PackageReference Include="System.Drawing.Common" Version="10.0.11" />
</ItemGroup>
<ItemGroup>
@@ -17,6 +17,7 @@ public sealed class ActiveDirectorySynchronizer(
private const int InfoAttributeMaximumLength = 1024;
private const int AccountDisabled = 0x0002;
private const int NormalAccount = 0x0200;
private const int ReversiblePasswordEncryptionAllowed = 0x0080;
private static readonly Guid ChangePasswordExtendedRight =
new("AB721A53-1E2F-11D0-9819-00AA0040529B");
private static readonly SecurityIdentifier EveryoneSid =
@@ -131,6 +132,10 @@ public sealed class ActiveDirectorySynchronizer(
// which ADSI SetPassword uses for each successful authentication.
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.
// It is not derived, transformed, written to disk, or included in logs.
user.Invoke("SetPassword", [password]);
@@ -142,6 +147,7 @@ public sealed class ActiveDirectorySynchronizer(
user.CommitChanges();
TryApplyProfile(user, identity, profile, options.DefaultCompany, logger);
TryApplyPhoto(user, identity.UserName, profile?.ThumbnailPhoto);
TryEnsureRemoteDesktopGroupMembership(user, identity.UserName);
return new DirectorySyncResult(
@@ -174,6 +180,23 @@ public sealed class ActiveDirectorySynchronizer(
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)
{
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(
DirectoryEntry entry,
InstitutionalGender? gender,
@@ -1,4 +1,6 @@
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Net;
using System.Text;
using System.Text.Json;
@@ -11,6 +13,9 @@ namespace SGU.AuthBroker.Services;
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 ILogger<NtlmCredentialValidator> logger;
private readonly Func<CredentialCache, CookieContainer, HttpMessageHandler> handlerFactory;
@@ -353,6 +358,20 @@ public sealed class NtlmCredentialValidator : INtlmCredentialValidator
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)
{
logger.LogWarning(
@@ -680,6 +699,135 @@ public sealed class NtlmCredentialValidator : INtlmCredentialValidator
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(
HttpClient client,
Uri requestedUri,
+2 -1
View File
@@ -67,7 +67,8 @@ internal sealed class BrokerClient : IDisposable
return BrokerDecision.Authorized(authorized.Domain, authorized.UserName);
}
return BrokerDecision.Unavailable($"BROKER_HTTP_{(int)response.StatusCode}");
ErrorBody? unavailable = await ReadJsonAsync<ErrorBody>(response, timeout.Token).ConfigureAwait(false);
return BrokerDecision.Unavailable(unavailable?.Code ?? $"BROKER_HTTP_{(int)response.StatusCode}");
}
catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
{
@@ -80,17 +80,27 @@ internal sealed class SguCredentialTile : CredentialTile3
return DomainCredential(decision.Domain!, decision.UserName!, securePassword);
}
// An SGU rejection does not create an account. Pass the unchanged
// credential to Windows so an existing AD account with the same
// name can still authenticate. A non-existent account is rejected
// by the domain controller.
// An explicit SGU rejection is authoritative even when an older AD
// verifier for the same institutional key still exists.
if (decision.Kind == BrokerDecisionKind.InvalidCredentials)
{
return Failure("Usuario o contraseña incorrectos.");
}
// SGU accepted this password but AD could not record it. Windows
// must not attempt a logon against a stale AD password.
if (decision.ErrorCode == "DIRECTORY_SYNCHRONIZATION_FAILED")
{
return Failure("La contraseña institucional fue aceptada, pero no se pudo preparar la cuenta en Active Directory. Intenta nuevamente o contacta a soporte.");
}
// Only a genuine broker/SGU outage permits the documented cached
// domain-credential path for an existing account.
return DomainCredential(
domain,
userName,
securePassword,
decision.Kind == BrokerDecisionKind.Unavailable
? "El servicio institucional no está disponible; Windows validará la contraseña guardada en el dominio."
: null);
"El servicio de autenticación no está disponible; Windows validará la última contraseña de dominio registrada.");
}
finally
{
@@ -2,9 +2,15 @@ $repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
$synchronizerPath = Join-Path $repositoryRoot 'src\SGU.AuthBroker\Services\ActiveDirectorySynchronizer.cs'
$deployPath = Join-Path $repositoryRoot 'scripts\Deploy-AuthBroker.ps1'
$userPolicyPath = Join-Path $repositoryRoot 'scripts\Set-SguDomainUserPolicies.ps1'
$passwordPolicyPath = Join-Path $repositoryRoot 'scripts\Set-SguInstitutionalPasswordPolicy.ps1'
$bootstrapPath = Join-Path $repositoryRoot 'scripts\Initialize-SguDomainController.ps1'
$packagePath = Join-Path $repositoryRoot 'scripts\New-SguBootstrapPackages.ps1'
$synchronizer = Get-Content -LiteralPath $synchronizerPath -Raw
$deploy = Get-Content -LiteralPath $deployPath -Raw
$userPolicy = Get-Content -LiteralPath $userPolicyPath -Raw
$passwordPolicy = Get-Content -LiteralPath $passwordPolicyPath -Raw
$bootstrap = Get-Content -LiteralPath $bootstrapPath -Raw
$package = Get-Content -LiteralPath $packagePath -Raw
Describe 'SGU Auth Broker password authority' {
It 'denies the Change Password extended right to SELF and Everyone before SetPassword' {
@@ -25,4 +31,17 @@ Describe 'SGU Auth Broker password authority' {
$userPolicy | Should Match "disableChangePasswordValueName = 'DisableChangePassword'"
$userPolicy | Should Match '(?s)-ValueName \$disableChangePasswordValueName.*-Type DWord.*-Value 1'
}
It 'scopes exact 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'"
}
}
+36
View File
@@ -0,0 +1,36 @@
$ErrorActionPreference='Stop'
$script=Join-Path $PSScriptRoot '..\scripts\Set-SguCedClientNetwork.ps1'
$root=Join-Path ([IO.Path]::GetTempPath()) ('ced-network-test-'+[guid]::NewGuid().ToString('N'))
$priorWindows=$env:WINDIR;$priorData=$env:ProgramData;$priorName=$env:COMPUTERNAME
function Assert($Condition,$Message){if(-not $Condition){throw $Message}}
try{
$env:WINDIR=$root;$env:ProgramData=$root;$env:COMPUTERNAME='AF-99'
New-Item (Join-Path $root 'System32\drivers\etc'),(Join-Path $root 'LCI-Admin\CED-WiFi') -ItemType Directory -Force|Out-Null
$hosts=Join-Path $root 'System32\drivers\etc\hosts'
function Get-CimInstance { [pscustomobject]@{PartOfDomain=$true;DomainRole=1;Domain='lci.lasalle.mx'} }
function Clear-DnsClientCache {}
[IO.File]::WriteAllText($hosts,"127.0.0.1 localhost`r`n20.9.81.130 sgu-dc01.lci.lasalle.mx lci.lasalle.mx sgu-auth.lci.lasalle.mx rustdesk.lci.lasalle.mx # SGU managed direct enrollment`r`n")
$first=& $script
$text=[IO.File]::ReadAllText($hosts)
Assert $first.HostsChanged 'Expected legacy entry migration.'
Assert ($text.Contains('sgu-auth.lci.lasalle.mx rustdesk.lci.lasalle.mx # SGU managed direct enrollment')) 'Broker and remote-access aliases were lost.'
Assert (([regex]::Matches($text,'(?i)sgu-dc01\.lci\.lasalle\.mx')).Count -eq 1) 'Duplicate DC host aliases.'
$second=& $script
Assert (-not $second.HostsChanged) 'Repeated application modified hosts.'
[IO.File]::WriteAllText($hosts,"192.168.1.1 SGU-DC01.lci.lasalle.mx`r`n")
$conflict=$false
try{& $script|Out-Null}catch{$conflict=$true}
Assert $conflict 'Unmanaged host conflict was silently overwritten.'
Assert ([IO.File]::ReadAllText($hosts) -eq "192.168.1.1 SGU-DC01.lci.lasalle.mx`r`n") 'Conflict changed hosts.'
$env:COMPUTERNAME='APPS-01'
& $script|Out-Null
Assert ([IO.File]::ReadAllText($hosts) -eq "192.168.1.1 SGU-DC01.lci.lasalle.mx`r`n") 'Ethernet workstation was changed.'
'CED network tests passed: migration, preservation, idempotence, conflict and scope.'
}finally{
$env:WINDIR=$priorWindows;$env:ProgramData=$priorData;$env:COMPUTERNAME=$priorName
# Remove only the freshly created, validated temporary test directory.
$resolved=[IO.Path]::GetFullPath($root)
if($resolved.StartsWith([IO.Path]::GetTempPath(),[StringComparison]::OrdinalIgnoreCase) -and (Split-Path $resolved -Leaf) -like 'ced-network-test-*'){
Remove-Item -LiteralPath $resolved -Recurse -Force
}
}
@@ -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'
}
}
@@ -1,5 +1,7 @@
using System.Net;
using System.Net.Http.Headers;
using System.Drawing;
using System.Drawing.Imaging;
using Microsoft.Extensions.Logging.Abstractions;
using SGU.AuthBroker.Core.Authentication;
using SGU.AuthBroker.Core.Identity;
@@ -163,7 +165,8 @@ public sealed class NtlmCredentialValidatorTests
"""),
JsonResponse("""
{"d":[{"p_IdCP":"090001","p_Nombre":"FLORIDA","p_Cp":"01000"}]}
"""));
"""),
PhotoResponse(TestJpeg()));
NtlmCredentialValidator validator = CreateValidator(handler);
NtlmValidationResult result = await validator.ValidateAsync(
@@ -184,6 +187,7 @@ public sealed class NtlmCredentialValidatorTests
Assert.Equal("Ciudad de México", result.Profile.State);
Assert.Equal("01000", result.Profile.PostalCode);
Assert.Equal(InstitutionalGender.Female, result.Profile.Gender);
Assert.Equal(TestJpeg(), result.Profile.ThumbnailPhoto);
Assert.Equal(
[
"/psulsa/",
@@ -193,7 +197,8 @@ public sealed class NtlmCredentialValidatorTests
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx",
"/psulsa/gadmon/capitalhumano/datos/ubicacion.aspx/GetDireccion",
"/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);
Assert.Equal("{\"CodigoPostal\":\"01000\"}", handler.RequestBodies[5]);
@@ -201,6 +206,9 @@ public sealed class NtlmCredentialValidatorTests
Assert.Equal(
"{\"pIdEstado\":\"\",\"pLocalidad\":\"\",\"CodigoPostal\":\"01000\"}",
handler.RequestBodies[7]);
Assert.Equal(
"https://sgu.example/psulsa/gadmon/admonPersonal/ashx/Fotografia.ashx?id=017045&tp=2",
handler.RequestUris[8]);
}
[Fact]
@@ -278,7 +286,8 @@ public sealed class NtlmCredentialValidatorTests
"""),
JsonResponse("""
{"d":[{"p_IdCP":"090001","p_Nombre":"FLORIDA","p_Cp":"01000"}]}
"""));
"""),
Response(HttpStatusCode.NotFound));
NtlmCredentialValidator validator = CreateValidator(handler);
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/GetDireccion",
"/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);
Assert.Equal(
"https://sgu.example/psulsa/gadmon/admonPersonal/ashx/Fotografia.ashx?id=123456&tp=2",
handler.RequestUris[9]);
}
[Fact]
@@ -347,6 +360,109 @@ public sealed class NtlmCredentialValidatorTests
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)
{
BrokerOptions options = new()
@@ -406,6 +522,8 @@ public sealed class NtlmCredentialValidatorTests
public List<string> RequestPaths { get; } = [];
public List<string> RequestUris { get; } = [];
public List<string?> RequestBodies { get; } = [];
protected override Task<HttpResponseMessage> SendAsync(
@@ -414,6 +532,7 @@ public sealed class NtlmCredentialValidatorTests
{
cancellationToken.ThrowIfCancellationRequested();
RequestPaths.Add(request.RequestUri!.AbsolutePath);
RequestUris.Add(request.RequestUri.AbsoluteUri);
RequestBodies.Add(request.Content is null
? null
: request.Content.ReadAsStringAsync(cancellationToken).GetAwaiter().GetResult());
@@ -46,6 +46,7 @@ public sealed class BrokerClientTests
TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.InvalidCredentials, decision.Kind);
Assert.Equal("INVALID_INSTITUTIONAL_CREDENTIALS", decision.ErrorCode);
}
[Fact]
@@ -61,6 +62,23 @@ public sealed class BrokerClientTests
TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind);
Assert.Equal("NTLM_UPSTREAM_ERROR", decision.ErrorCode);
}
[Fact]
public async Task SynchronizationFailureRetainsItsSpecificErrorCode()
{
using BrokerClient client = new(
CreateSettings(),
new CapturingHandler(HttpStatusCode.ServiceUnavailable, "{\"code\":\"DIRECTORY_SYNCHRONIZATION_FAILED\"}"));
BrokerDecision decision = await client.AuthenticateAsync(
"AL250792",
"SGUAccepted",
TestContext.Current.CancellationToken);
Assert.Equal(BrokerDecisionKind.Unavailable, decision.Kind);
Assert.Equal("DIRECTORY_SYNCHRONIZATION_FAILED", decision.ErrorCode);
}
private static ProviderSettings CreateSettings() => new()