Compare commits

...
10 Commits
36 changed files with 2140 additions and 10 deletions

No files matched your search

+1
View File
@@ -60,6 +60,7 @@ visible while the browser populates those controls asynchronously.
Operational documentation: Operational documentation:
- [Centro de Experiencia Digital Wi-Fi policy and management](docs/ced-network-operations.md)
- [One-command server recovery and client enrollment](docs/bootstrap-recovery.md) - [One-command server recovery and client enrollment](docs/bootstrap-recovery.md)
- [Broker location, health, timeout, and recovery](docs/broker-operations.md) - [Broker location, health, timeout, and recovery](docs/broker-operations.md)
- [Windows domain join and remote-access onboarding](docs/windows-client-onboarding.md) - [Windows domain join and remote-access onboarding](docs/windows-client-onboarding.md)
+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.
+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.
+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.
+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
}
@@ -12,7 +12,7 @@ if (-not $computer.PartOfDomain -or $computer.DomainRole -ne 1) { return }
# A site-local DNS server is optional. Change only an adapter whose directly # A site-local DNS server is optional. Change only an adapter whose directly
# connected subnet contains that server, after verifying its authoritative DNS # connected subnet contains that server, after verifying its authoritative DNS
# answer. Other sites, VPN adapters and Internet-only interfaces are preserved. # answer. Other sites, VPN adapters and Internet-only interfaces are preserved.
if ($LocalDnsServer) { if ($LocalDnsServer -and $env:COMPUTERNAME -notmatch '^(AF|SD|SI)-') {
$dnsBytes = ([Net.IPAddress]::Parse($LocalDnsServer)).GetAddressBytes() $dnsBytes = ([Net.IPAddress]::Parse($LocalDnsServer)).GetAddressBytes()
foreach ($ip in @(Get-NetIPAddress -AddressFamily IPv4 | Where-Object { foreach ($ip in @(Get-NetIPAddress -AddressFamily IPv4 | Where-Object {
$_.AddressState -eq 'Preferred' -and $_.PrefixLength -gt 0 -and $_.PrefixLength -lt 32 $_.AddressState -eq 'Preferred' -and $_.PrefixLength -gt 0 -and $_.PrefixLength -lt 32
+75
View File
@@ -0,0 +1,75 @@
[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
$searchRoot=[DirectoryServices.DirectoryEntry]::new("LDAP://$primaryDomainController/CN=Policies,CN=System,"+$domainDn,$null,$null,$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
@@ -23,6 +23,11 @@ if (-not $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administra
Import-Module ActiveDirectory -ErrorAction Stop Import-Module ActiveDirectory -ErrorAction Stop
Import-Module GroupPolicy -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 $domain = Get-ADDomain -Server $DomainController -ErrorAction Stop
$domainDnsRoot = $domain.DNSRoot $domainDnsRoot = $domain.DNSRoot
@@ -83,7 +88,11 @@ Set-ItemProperty -Path `$logonUiPath -Name LastLoggedOnProvider -Value '{D789CFD
`$updateRoot = Join-Path `$env:ProgramData "SGU\CredentialProviderUpdates\`$version" `$updateRoot = Join-Path `$env:ProgramData "SGU\CredentialProviderUpdates\`$version"
`$markerPath = Join-Path `$updateRoot 'complete.marker' `$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 exit 0
} }
@@ -139,10 +148,12 @@ if (-not `$runtimeInstalled) {
& `$installScript @installParameters | Out-Null & `$installScript @installParameters | Out-Null
[IO.File]::WriteAllText(`$markerPath, (Get-Date).ToUniversalTime().ToString('o'), [Text.UTF8Encoding]::new(`$false)) [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")) { if ($PSCmdlet.ShouldProcess($startupPath, "Install '$scriptName' as a computer startup script")) {
New-Item -ItemType Directory -Path $startupPath -Force | Out-Null 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)) [IO.File]::WriteAllText($scriptPath, $startupScript, [Text.UTF8Encoding]::new($false))
$scriptUncPath = "\\$domainDnsRoot\SYSVOL\$domainDnsRoot\Policies\{$($gpo.Id)}\Machine\Scripts\Startup\$scriptName" $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" $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]$CollectorFqdn = "$env:COMPUTERNAME.$env:USERDNSDOMAIN",
[string]$ComputerOuDn = 'OU=Laboratorio,DC=lci,DC=lasalle,DC=mx', [string]$ComputerOuDn = 'OU=Laboratorio,DC=lci,DC=lasalle,DC=mx',
[string]$MonitoringRoot = 'C:\ProgramData\SGU\Monitoring', [string]$MonitoringRoot = 'C:\ProgramData\SGU\Monitoring',
[ValidateRange(5,1440)]
[int]$InventoryIntervalMinutes = 60,
[ValidateRange(30, 730)] [ValidateRange(30, 730)]
[int]$RetentionDays = 183 [int]$RetentionDays = 183
) )
@@ -114,7 +116,7 @@ if ($PSCmdlet.ShouldProcess($env:COMPUTERNAME, 'Install the SGU domain monitorin
"-NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$maintenanceScript`" " + "-NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File `"$maintenanceScript`" " +
"-MonitoringRoot `"$MonitoringRoot`" -ComputerOuDn `"$ComputerOuDn`" -RetentionDays $RetentionDays -InventoryOnly") "-MonitoringRoot `"$MonitoringRoot`" -ComputerOuDn `"$ComputerOuDn`" -RetentionDays $RetentionDays -InventoryOnly")
$inventoryTrigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(1) ` $inventoryTrigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(1) `
-RepetitionInterval (New-TimeSpan -Minutes 5) ` -RepetitionInterval (New-TimeSpan -Minutes $InventoryIntervalMinutes) `
-RepetitionDuration (New-TimeSpan -Days 3650) -RepetitionDuration (New-TimeSpan -Days 3650)
$taskSettings = New-ScheduledTaskSettingsSet -StartWhenAvailable ` $taskSettings = New-ScheduledTaskSettingsSet -StartWhenAvailable `
-ExecutionTimeLimit (New-TimeSpan -Minutes 10) -RestartCount 2 ` -ExecutionTimeLimit (New-TimeSpan -Minutes 10) -RestartCount 2 `
+3
View File
@@ -25,6 +25,9 @@ param(
) )
$ErrorActionPreference = 'Stop' $ErrorActionPreference = 'Stop'
if ((Get-ItemProperty 'HKLM:\SOFTWARE\Policies\LaSalle\ClientMaintenance' -Name ProviderManagedByGpo -ErrorAction SilentlyContinue).ProviderManagedByGpo -eq 1) {
return
}
$taskName = 'SGU-CredentialProvider-EnrollmentGuard' $taskName = 'SGU-CredentialProvider-EnrollmentGuard'
$enrollmentRoot = Join-Path $env:ProgramData 'SGU\Enrollment' $enrollmentRoot = Join-Path $env:ProgramData 'SGU\Enrollment'
$sourceScripts = @( $sourceScripts = @(
+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}
+47 -4
View File
@@ -91,20 +91,22 @@ $clientRoot = Join-Path $resolvedOutputRoot "sgu-windows-client-bootstrap-$Versi
$serverRoot = Join-Path $resolvedOutputRoot "sgu-server-bootstrap-$Version" $serverRoot = Join-Path $resolvedOutputRoot "sgu-server-bootstrap-$Version"
$linuxClientRoot = Join-Path $resolvedOutputRoot "sgu-linux-client-bootstrap-$Version" $linuxClientRoot = Join-Path $resolvedOutputRoot "sgu-linux-client-bootstrap-$Version"
$azureRoot = Join-Path $resolvedOutputRoot "sgu-azure-infrastructure-$Version" $azureRoot = Join-Path $resolvedOutputRoot "sgu-azure-infrastructure-$Version"
$wifiRoot = Join-Path $resolvedOutputRoot "sgu-ced-wifi-policy-$Version"
$clientZip = "$clientRoot.zip" $clientZip = "$clientRoot.zip"
$serverZip = "$serverRoot.zip" $serverZip = "$serverRoot.zip"
$linuxClientZip = "$linuxClientRoot.zip" $linuxClientZip = "$linuxClientRoot.zip"
$azureZip = "$azureRoot.zip" $azureZip = "$azureRoot.zip"
$wifiZip = "$wifiRoot.zip"
foreach ($target in @( foreach ($target in @(
$clientRoot,$serverRoot,$linuxClientRoot,$azureRoot, $clientRoot,$serverRoot,$linuxClientRoot,$azureRoot,$wifiRoot,
$clientZip,$serverZip,$linuxClientZip,$azureZip)) { $clientZip,$serverZip,$linuxClientZip,$azureZip,$wifiZip)) {
if (Test-Path -LiteralPath $target) { if (Test-Path -LiteralPath $target) {
throw "Release target already exists: $target" throw "Release target already exists: $target"
} }
} }
New-Item -ItemType Directory ` New-Item -ItemType Directory `
-Path $clientRoot,$serverRoot,$linuxClientRoot,$azureRoot ` -Path $clientRoot,$serverRoot,$linuxClientRoot,$azureRoot,$wifiRoot `
-Force | Out-Null -Force | Out-Null
$welcomeFontNames = @( $welcomeFontNames = @(
'IndivisaTextSans-Regular.otf', 'IndivisaTextSans-Regular.otf',
@@ -206,6 +208,17 @@ Copy-RequiredFile -Source (Join-Path $PSScriptRoot 'Start-SguServerBootstrap.cmd
Copy-RequiredFile -Source (Join-Path $PSScriptRoot 'Start-SguAzureServerBootstrap.cmd') ` Copy-RequiredFile -Source (Join-Path $PSScriptRoot 'Start-SguAzureServerBootstrap.cmd') `
-Destination (Join-Path $serverRoot 'Start-SguAzureServerBootstrap.cmd') -Destination (Join-Path $serverRoot 'Start-SguAzureServerBootstrap.cmd')
$serverScripts = @( $serverScripts = @(
'Set-SguCedWifiPolicy.ps1',
'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', 'Deploy-AuthBroker.ps1',
'Disable-SguAzureUserRoaming.ps1', 'Disable-SguAzureUserRoaming.ps1',
'Enable-SguAzureUserRoaming.ps1', 'Enable-SguAzureUserRoaming.ps1',
@@ -267,7 +280,7 @@ foreach ($fontName in $welcomeFontNames) {
Copy-RequiredFile -Source (Join-Path $repositoryRoot "assets\branding\fonts\$fontName") ` Copy-RequiredFile -Source (Join-Path $repositoryRoot "assets\branding\fonts\$fontName") `
-Destination (Join-Path $serverContentTarget "welcome-wallpaper\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") ` Copy-RequiredFile -Source (Join-Path $repositoryRoot "docs\$documentation") `
-Destination (Join-Path $serverRoot "docs\$documentation") -Destination (Join-Path $serverRoot "docs\$documentation")
} }
@@ -298,11 +311,39 @@ Write-PackageManifest -PackageRoot $azureRoot -PackageVersion $Version -PackageK
Compress-Archive -Path (Join-Path $azureRoot '*') -DestinationPath $azureZip ` Compress-Archive -Path (Join-Path $azureRoot '*') -DestinationPath $azureZip `
-CompressionLevel Optimal -CompressionLevel Optimal
# Existing domains can publish the WLAN correction without running forest setup.
foreach ($scriptName in @(
'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 = @( $checksums = @(
("{0} {1}" -f (Get-FileHash -LiteralPath $clientZip -Algorithm SHA256).Hash, (Split-Path $clientZip -Leaf)) ("{0} {1}" -f (Get-FileHash -LiteralPath $clientZip -Algorithm SHA256).Hash, (Split-Path $clientZip -Leaf))
("{0} {1}" -f (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash, (Split-Path $serverZip -Leaf)) ("{0} {1}" -f (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash, (Split-Path $serverZip -Leaf))
("{0} {1}" -f (Get-FileHash -LiteralPath $linuxClientZip -Algorithm SHA256).Hash, (Split-Path $linuxClientZip -Leaf)) ("{0} {1}" -f (Get-FileHash -LiteralPath $linuxClientZip -Algorithm SHA256).Hash, (Split-Path $linuxClientZip -Leaf))
("{0} {1}" -f (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash, (Split-Path $azureZip -Leaf)) ("{0} {1}" -f (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash, (Split-Path $azureZip -Leaf))
("{0} {1}" -f (Get-FileHash -LiteralPath $wifiZip -Algorithm SHA256).Hash, (Split-Path $wifiZip -Leaf))
) )
$checksumsPath = Join-Path $resolvedOutputRoot "SHA256SUMS-$Version.txt" $checksumsPath = Join-Path $resolvedOutputRoot "SHA256SUMS-$Version.txt"
[IO.File]::WriteAllLines($checksumsPath, $checksums, [Text.UTF8Encoding]::new($false)) [IO.File]::WriteAllLines($checksumsPath, $checksums, [Text.UTF8Encoding]::new($false))
@@ -317,6 +358,8 @@ $checksumsPath = Join-Path $resolvedOutputRoot "SHA256SUMS-$Version.txt"
ServerSha256 = (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash ServerSha256 = (Get-FileHash -LiteralPath $serverZip -Algorithm SHA256).Hash
AzureInfrastructurePackage = $azureZip AzureInfrastructurePackage = $azureZip
AzureInfrastructureSha256 = (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash AzureInfrastructureSha256 = (Get-FileHash -LiteralPath $azureZip -Algorithm SHA256).Hash
CedWifiPolicyPackage = $wifiZip
CedWifiPolicySha256 = (Get-FileHash -LiteralPath $wifiZip -Algorithm SHA256).Hash
Checksums = $checksumsPath Checksums = $checksumsPath
RuntimeInstaller = $runtimeInstaller.Name RuntimeInstaller = $runtimeInstaller.Name
} }
+8 -1
View File
@@ -23,6 +23,7 @@ $assetPaths = @(
(Join-Path $ReleaseDirectory "sgu-server-bootstrap-$Version.zip"), (Join-Path $ReleaseDirectory "sgu-server-bootstrap-$Version.zip"),
(Join-Path $ReleaseDirectory "sgu-linux-client-bootstrap-$Version.zip"), (Join-Path $ReleaseDirectory "sgu-linux-client-bootstrap-$Version.zip"),
(Join-Path $ReleaseDirectory "sgu-azure-infrastructure-$Version.zip"), (Join-Path $ReleaseDirectory "sgu-azure-infrastructure-$Version.zip"),
(Join-Path $ReleaseDirectory "sgu-ced-wifi-policy-$Version.zip"),
(Join-Path $ReleaseDirectory "SHA256SUMS-$Version.txt") (Join-Path $ReleaseDirectory "SHA256SUMS-$Version.txt")
) )
foreach ($assetPath in $assetPaths) { foreach ($assetPath in $assetPaths) {
@@ -143,7 +144,8 @@ Las contraseñas se solicitan de forma interactiva y no se escriben en archivos
target_commitish = $TargetCommitish target_commitish = $TargetCommitish
name = "SGU Credential Provider $Version" name = "SGU Credential Provider $Version"
body = $releaseNotes body = $releaseNotes
draft = [bool]$Draft # Keep the release private until every attachment has uploaded.
draft = $true
prerelease = $Version -match '-' prerelease = $Version -match '-'
} }
@@ -175,6 +177,11 @@ Las contraseñas se solicitan de forma interactiva y no se escriben en archivos
} }
} }
if (-not $Draft) {
$release = Invoke-GiteaJson -Method ([Net.Http.HttpMethod]::Patch) `
-RelativeUri "$repositoryPath/releases/$($release.id)" -Body @{draft=$false}
}
[pscustomobject]@{ [pscustomobject]@{
Tag = $tagName Tag = $tagName
ReleaseName = $release.name ReleaseName = $release.name
+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' $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 $configuration = Get-Content -LiteralPath $ConfigurationPath -Raw | ConvertFrom-Json
$enrollmentRoot = Split-Path $ConfigurationPath -Parent $enrollmentRoot = Split-Path $ConfigurationPath -Parent
$testScript = Join-Path $enrollmentRoot 'Test-SguClientEnrollment.ps1' $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}
+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.' }
+13 -2
View File
@@ -3,6 +3,7 @@ param(
[Parameter(Mandatory)][uri]$Endpoint, [Parameter(Mandatory)][uri]$Endpoint,
[Parameter(Mandatory)][PSCredential]$Credential, [Parameter(Mandatory)][PSCredential]$Credential,
[string]$DomainController = $env:COMPUTERNAME, [string]$DomainController = $env:COMPUTERNAME,
[string]$ComputerOuDn = '',
[string[]]$VerifyNodes = @() [string[]]$VerifyNodes = @()
) )
$ErrorActionPreference = 'Stop' $ErrorActionPreference = 'Stop'
@@ -54,7 +55,12 @@ $login = Invoke-WebRequest -Uri "$base/api/user/login" -Method Post -WebSession
if ($login.StatusCode -ne 200) { throw 'WAC rejected the supplied account.' } if ($login.StatusCode -ne 200) { throw 'WAC rejected the supplied account.' }
$existing = Invoke-RestMethod -Uri "$base/api/connections" -WebSession $webSession $existing = Invoke-RestMethod -Uri "$base/api/connections" -WebSession $webSession
$computers = @(Get-ADComputer -Server $DomainController -Filter 'Enabled -eq $true' -Properties OperatingSystem,DNSHostName | $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*' }) Where-Object { $_.DNSHostName -and $_.OperatingSystem -like 'Windows*' })
$pending = @( $pending = @(
foreach ($computer in $computers) { foreach ($computer in $computers) {
@@ -84,9 +90,14 @@ if ($missing.Count) { throw "WAC inventory verification failed: $($missing.Name
foreach ($node in $VerifyNodes) { foreach ($node in $VerifyNodes) {
if ($node -notmatch '^[A-Za-z0-9.-]+$') { throw 'Invalid verification hostname.' } 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" $uri = "$base/api/services/WinREST/CIM/nodes/$node/namespaces/root.cimv2/classes/Win32_OperatingSystem/instances"
try {
$response = Invoke-WebRequest -Uri $uri -WebSession $webSession -UseBasicParsing $response = Invoke-WebRequest -Uri $uri -WebSession $webSession -UseBasicParsing
$result = $response.Content | ConvertFrom-Json $result = $response.Content | ConvertFrom-Json
$instances = @($result.value | Where-Object { $null -ne $_ }) $instances = @($result.value | Where-Object { $null -ne $_ })
if (-not $instances.Count) { throw "WAC returned no OS instances for $node." } if (-not $instances.Count) { throw "WAC returned no OS instances for $node." }
[pscustomobject]@{Node=$node;Status=$response.StatusCode;Instances=$instances.Count;ReturnedData=$true} [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"]
}
+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
}
}