Architecture et composants internes¶

Les trois couches d'une GPO¶

Une GPO n'est pas un objet unique. C'est une construction distribuée composée de trois éléments distincts qui doivent rester cohérents entre eux.

La compréhension de cette architecture est fondamentale. La quasi-totalité des incidents de stratégie de groupe — paramètres non appliqués, erreurs dans les journaux, comportements incohérents entre DC — trouve son explication dans la relation entre ces trois couches.

GPC (Group Policy Container) — côté Active Directory (réplication AD)

GPT (Group Policy Template) — côté SYSVOL (réplication DFS-R ou FRS)

gPLink — l'attribut de lien sur le conteneur (Site, Domaine, OU)

Le GPC — Group Policy Container¶

Le GPC est un objet Active Directory de classe groupPolicyContainer. Il réside sous :

CN=Policies,CN=System,DC=contoso,DC=local

Chaque GPO possède son propre GPC, identifié par un GUID unique. Ce GUID est stable pour toute la durée de vie de la GPO — il ne change pas si on renomme la GPO.

Attributs LDAP du GPC¶

L'attribut flags contrôle quelles portions de la GPO sont actives :

Lire les attributs GPC avec PowerShell¶

# Read GPC attributes for a specific GPO
$gpo = Get-GPO -Name "Default Domain Policy"
$domain = (Get-ADDomain).DistinguishedName

Get-ADObject `
    -Identity "CN={$($gpo.Id)},CN=Policies,CN=System,$domain" `
    -Properties gPCFileSysPath,
                versionNumber,
                flags,
                gPCFunctionalityVersion,
                gPCMachineExtensionNames,
                gPCUserExtensionNames |
    Select-Object Name, displayName, versionNumber, flags,
                  gPCFileSysPath, gPCMachineExtensionNames

Name              : {31B2F340-016D-11D2-945F-00C04FB984F9}
displayName       : Default Domain Policy
versionNumber     : 131073
flags             : 0
gPCFileSysPath    : \\contoso.local\SYSVOL\contoso.local\Policies\{31B2F340-016D-11D2-945F-00C04FB984F9}
gPCMachineExtensionNames : [{35378EAC-683F-11D2-A89A-00C04FBBCFA2}{53D6AB1B-2488-11D1-A28C-00C04FB94F17}]
                           [{827D319E-6EAC-11D2-A4EA-00C04F79F83A}{803E14A0-B4FB-11D0-A0D0-00A0C90F574B}]

Le GPT — Group Policy Template¶

Le GPT est une arborescence de dossiers et fichiers dans SYSVOL. Son emplacement est toujours :

\\<domaine>\SYSVOL\<domaine>\Policies\{GUID}\

Ce chemin est précisément l'attribut gPCFileSysPath du GPC correspondant.

Structure de l'arborescence GPT¶

{GUID}\
├── GPT.INI                                    ← synchronisation de version
│
├── Machine\
│   ├── Registry.pol                           ← paramètres registre (format binaire)
│   ├── Microsoft\
│   │   └── Windows NT\
│   │       └── SecEdit\
│   │           └── GptTmpl.inf               ← paramètres de sécurité (format INI)
│   ├── Scripts\
│   │   ├── Startup\                           ← scripts de démarrage
│   │   └── Shutdown\                          ← scripts d'arrêt
│   └── Preferences\
│       ├── Registry\                          ← préférences registre (XML)
│       ├── Files\                             ← préférences fichiers (XML)
│       ├── Shortcuts\                         ← préférences raccourcis (XML)
│       └── ...                               ← autres catégories GPP
│
└── User\
    ├── Registry.pol                           ← paramètres registre utilisateur
    ├── Scripts\
    │   ├── Logon\                             ← scripts de connexion
    │   └── Logoff\                            ← scripts de déconnexion
    └── Preferences\
        ├── Registry\
        └── ...

Chaque sous-dossier n'existe que si au moins un paramètre de cette catégorie est configuré dans la GPO. Une GPO vide ne contient que GPT.INI.

Le fichier GPT.INI¶

GPT.INI est le fichier de synchronisation de version entre le GPC (AD) et le GPT (SYSVOL). Son contenu est minimal :

[General]
Version=131073
displayName=New Group Policy Object

La valeur Version doit être identique à l'attribut versionNumber du GPC. Toute divergence déclenche une erreur côté client.

Le champ displayName dans GPT.INI est une relique historique. Il n'est pas utilisé par le client GPO moderne — c'est l'attribut displayName du GPC qui fait foi.

Décodage du numéro de version¶

La valeur de version est un entier 32 bits encodé ainsi :

• Bits 0–15 (poids faible) : version de la politique Machine
• Bits 16–31 (poids fort) : version de la politique Utilisateur

Chaque modification dans la partie Machine incrémente le compteur bas. Chaque modification dans la partie Utilisateur incrémente le compteur haut. Les deux compteurs sont indépendants.

# Decode version number from GPT.INI or AD versionNumber
$version = 131073  # 0x00020001

$machineVersion = $version -band 0xFFFF
$userVersion    = ($version -shr 16) -band 0xFFFF

[PSCustomObject]@{
    RawVersion     = $version
    HexVersion     = "0x{0:X8}" -f $version
    MachineVersion = $machineVersion
    UserVersion    = $userVersion
}

RawVersion     : 131073
HexVersion     : 0x00020001
MachineVersion : 1
UserVersion    : 2

Le lien GPO — l'attribut gPLink¶

Le lien GPO n'est pas un objet AD distinct. C'est un attribut (gPLink) posé directement sur l'objet Site, Domaine ou OU.

Cette conception a une implication directe : supprimer un lien GPO ne touche pas la GPO elle-même (son GPC et son GPT restent intacts). On ne fait que retirer une référence.

Format de l'attribut gPLink¶

Un attribut gPLink peut contenir plusieurs liens, chacun encapsulé entre crochets :

[LDAP://cn={GUID},cn=policies,cn=system,DC=contoso,DC=local;0][LDAP://cn={GUID2},...;2]

Chaque entrée se compose du chemin LDAP du GPC, suivi d'un point-virgule, suivi d'un flag numérique :

L'ordre des entrées dans gPLink est l'ordre de traitement. Le dernier lien listé est traité en premier (priorité décroissante de gauche à droite). La GPMC représente cet ordre visuellement avec des numéros d'ordre.

Lire et décoder gPLink avec PowerShell¶

# Read and decode GPO links on an OU
$ou = Get-ADOrganizationalUnit `
    -Identity "OU=Postes,DC=contoso,DC=local" `
    -Properties gPLink

if (-not $ou.gPLink) {
    Write-Output "No GPO links on this OU"
    return
}

$ou.gPLink -split '\]\[' |
    ForEach-Object {
        $entry = $_ -replace '^\[' -replace '\]$'
        if ($entry -match 'CN=\{([^}]+)\}') {
            $guid = $Matches[1]
        }
        $flag = ($entry -split ';')[-1]

        $flagLabel = switch ($flag) {
            '0' { 'Active' }
            '1' { 'Disabled' }
            '2' { 'Enforced' }
            default { "Unknown ($flag)" }
        }

        [PSCustomObject]@{
            GUID  = $guid
            Flag  = $flag
            State = $flagLabel
        }
    }

GUID                                   Flag  State
----                                   ----  -----
31B2F340-016D-11D2-945F-00C04FB984F9   0     Active
6AC1786C-016F-11D2-945F-00C04FB984F9   2     Enforced

Le service Group Policy Client — gpsvc¶

Le service gpsvc (Group Policy Client) est l'orchestrateur central du traitement des GPO sur le poste client. Il existe depuis Windows Vista — avant, le traitement était géré directement par winlogon.exe.

Caractéristiques techniques du service¶

La dépendance envers Mup (Multiple UNC Provider) est critique. Mup est le composant qui résout les chemins UNC (\\serveur\partage). Sans lui, gpsvc ne peut pas accéder au SYSVOL.

Responsabilités du service gpsvc¶

gpsvc orchestre l'intégralité du pipeline de traitement en quatre étapes :

1. Collecte de la liste des GPO applicables

gpsvc émet des requêtes LDAP vers un contrôleur de domaine pour récupérer les attributs gPLink de tous les conteneurs AD dans le chemin LSDOU du compte machine ou utilisateur. Il récupère ensuite les GPC correspondants pour obtenir versionNumber et gPCFileSysPath.

2. Accès au SYSVOL via SMB

Pour chaque GPO dont la version a changé depuis le dernier traitement, gpsvc télécharge le contenu du GPT via SMB. Le chemin d'accès vient directement de gPCFileSysPath.

3. Invocation des CSE

gpsvc charge et appelle chaque Client-Side Extension (CSE) dans l'ordre approprié. Seules les CSE référencées dans gPCMachineExtensionNames ou gPCUserExtensionNames sont invoquées.

4. Gestion du cache local

gpsvc maintient un cache local des paramètres reçus. Ce cache permet le traitement en mode hors connexion (si AllowX509CertificateForOfflineLogon ou mode offline configuré).

Structure du cache local¶

%SystemRoot%\System32\GroupPolicy\
├── Machine\
│   ├── Registry.pol         ← copie locale du registry.pol machine
│   └── Scripts\
│       ├── Startup\
│       └── Shutdown\
└── User\
    └── Registry.pol         ← non utilisé ici (voir ci-dessous)

%SystemRoot%\System32\GroupPolicyUsers\{SID utilisateur}\User\
└── Registry.pol             ← copie locale du registry.pol utilisateur par SID

Le cache utilisateur est isolé par SID. Chaque utilisateur qui s'est connecté sur le poste dispose de son propre répertoire sous GroupPolicyUsers. Cela permet d'appliquer les paramètres utilisateur corrects même si plusieurs profils coexistent.

Vérification du service avec PowerShell¶

# Check Group Policy Client service status
Get-Service gpsvc |
    Select-Object Name, DisplayName, Status, StartType

# Verify the service DLL path
Get-ItemProperty `
    -Path "HKLM:\SYSTEM\CurrentControlSet\Services\gpsvc\Parameters" |
    Select-Object ServiceDll

Name        DisplayName            Status  StartType
----        -----------            ------  ---------
gpsvc       Group Policy Client    Running Automatic

ServiceDll : %SystemRoot%\System32\gpsvc.dll

Architecture générale — flux d'application d'une GPO¶

Le diagramme suivant représente le flux complet d'une application de stratégie de groupe, du démarrage du poste jusqu'à l'écriture des paramètres dans le registre.

sequenceDiagram
    participant W as Workstation (gpsvc)
    participant DC as Domain Controller (LDAP)
    participant SY as SYSVOL (DFS-R / SMB)
    participant CSE as Client-Side Extensions

    Note over W: Démarrage ou rafraîchissement périodique

    W->>DC: LDAP — récupère gPLink sur Site / Domaine / OU
    DC-->>W: Liste des GPC avec versionNumber et gPCFileSysPath

    W->>W: Compare versionNumber avec le cache local
    Note over W: Si version identique → skip téléchargement

    W->>SY: SMB — télécharge GPT si version modifiée
    SY-->>W: Registry.pol, GptTmpl.inf, XML Preferences...

    W->>W: Lit gPCMachineExtensionNames / gPCUserExtensionNames
    Note over W: Détermine quelles CSE appeler

    loop Pour chaque CSE applicable
        W->>CSE: Invoke CSE (Process Group Policy)
        CSE->>W: Applique paramètres (registre, sécurité, scripts...)
    end

    W->>W: Met à jour le cache local (GroupPolicy\)
    W->>W: Écrit les événements dans le journal GP Operational

Le flux est identique pour les politiques Machine (au démarrage) et Utilisateur (à la connexion). Seul le contexte d'exécution change — SYSTEM pour Machine, session de l'utilisateur pour User.

La synchronisation GPC ↔ GPT : le numéro de version¶

La synchronisation entre le GPC (côté AD) et le GPT (côté SYSVOL) est le point de défaillance le plus fréquent dans les environnements GPO. Toute divergence du numéro de version déclenche une erreur de traitement côté client.

Pourquoi une divergence se produit-elle ?¶

Cause 1 — Latence de réplication SYSVOL

Quand un administrateur modifie une GPO, le PDC Emulator met à jour simultanément le GPC (via AD) et le GPT (via SYSVOL). La réplication AD est généralement plus rapide que la réplication SYSVOL (DFS-R). Un DC secondaire peut avoir la nouvelle version en AD mais pas encore dans SYSVOL.

Cause 2 — Corruption de GPT.INI

Une édition manuelle de GPT.INI, une erreur système ou un problème de permissions peut corrompre le fichier ou en modifier la valeur Version.

Cause 3 — Blocage de la réplication DFS-R

En environnement multi-site avec bande passante limitée, DFS-R peut être throttlé. Le GPT peut rester en retard de plusieurs cycles de réplication sur certains DC.

Cause 4 — Réplication FRS bloquée (environnements anciens)

Sur des domaines encore en mode de réplication FRS (Windows Server 2003/2008 non migrés vers DFS-R), les journaux FRS corrompus ou les conflits de réplication créent des divergences persistantes.

Détecter les divergences GPC/GPT avec PowerShell¶

# Detect GPC/GPT version mismatch for all GPOs in the domain
Get-GPO -All | ForEach-Object {
    $gpo = $_

    # GPC version: DS versions are split (machine + user)
    $gpcMachineVersion = $gpo.Computer.DSVersion
    $gpcUserVersion    = $gpo.User.DSVersion

    # Rebuild the combined versionNumber (same encoding as GPT.INI)
    $gpcCombined = ($gpcUserVersion -shl 16) -bor $gpcMachineVersion

    # Read GPT.INI from SYSVOL
    $gptPath = "\\$env:USERDNSDOMAIN\SYSVOL\$env:USERDNSDOMAIN\Policies\{$($gpo.Id)}\GPT.INI"

    if (Test-Path $gptPath) {
        $gptContent  = Get-Content $gptPath
        $gptVersionLine = $gptContent | Where-Object { $_ -match '^Version=' }
        $gptVersion  = [int]($gptVersionLine -replace 'Version=', '')

        $status = if ($gpcCombined -eq $gptVersion) { 'OK' } else { 'MISMATCH' }

        [PSCustomObject]@{
            GPO            = $gpo.DisplayName
            GUID           = $gpo.Id
            GPC_Combined   = $gpcCombined
            GPT_Version    = $gptVersion
            Status         = $status
        }
    } else {
        [PSCustomObject]@{
            GPO          = $gpo.DisplayName
            GUID         = $gpo.Id
            GPC_Combined = $gpcCombined
            GPT_Version  = 'N/A'
            Status       = 'GPT.INI UNREACHABLE'
        }
    }
} | Sort-Object Status -Descending | Format-Table -AutoSize

GPO                       GUID                                   GPC_Combined  GPT_Version  Status
---                       ----                                   ------------  -----------  ------
Baseline Workstations     6AC1786C-016F-11D2-945F-00C04FB984F9   196609        65537        MISMATCH
Default Domain Policy     31B2F340-016D-11D2-945F-00C04FB984F9   131073        131073       OK
Default Domain Controllers Policy  6AC1786C-016F-11D2-945F-00C04FCA48E2  65537  65537      OK

Événements Windows associés aux désynchronisations¶

Le journal GP Operational se consulte via l'Observateur d'événements sous : Applications and Services Logs\Microsoft\Windows\GroupPolicy\Operational

Les attributs gPCMachineExtensionNames et gPCUserExtensionNames¶

Ces deux attributs LDAP du GPC jouent un rôle déterminant dans les performances du traitement GPO. Ils indiquent au service gpsvc quelles CSE (Client-Side Extensions) sont nécessaires pour cette GPO.

Fonctionnement¶

À chaque traitement, gpsvc lit gPCMachineExtensionNames et gPCUserExtensionNames. Il n'invoque que les CSE dont le GUID apparaît dans ces attributs.

Cette conception est intentionnelle : une GPO qui ne configure que des paramètres de registre n'invoque pas la CSE de sécurité (secedit), ni celle de déploiement de logiciels, ni aucune autre. Le gain de performance est significatif dans les environnements avec de nombreuses GPO.

Format de l'attribut¶

Chaque attribut est une chaîne contenant des paires de GUID encapsulées dans des crochets :

[{CSE-GUID}{Tool-GUID}][{CSE2-GUID}{Tool2-GUID}]...

• Le CSE-GUID identifie l'extension côté client (la DLL qui applique les paramètres)
• Le Tool-GUID identifie l'outil de gestion associé (GPMC snap-in, ADMX tool, etc.)

Ces attributs sont mis à jour automatiquement par la GPMC (ou PowerShell) chaque fois qu'un paramètre est ajouté ou supprimé. Si vous supprimez tous les paramètres gérés par une CSE, son GUID disparaît de l'attribut — la CSE ne sera plus appelée pour cette GPO.

CSE communes et leurs GUID¶

Lire et décoder ces attributs avec PowerShell¶

# Decode CSE GUIDs used by a specific GPO (machine side)
$gpoDN = "CN={31B2F340-016D-11D2-945F-00C04FB984F9},CN=Policies,CN=System,DC=contoso,DC=local"

$gpcObj = Get-ADObject -Identity $gpoDN `
    -Properties gPCMachineExtensionNames, gPCUserExtensionNames

Write-Host "=== Machine CSE ==="
$gpcObj.gPCMachineExtensionNames -split '\]\[' |
    ForEach-Object {
        $entry = $_ -replace '^\[' -replace '\]$'
        if ($entry -match '^\{([^}]+)\}\{([^}]+)\}$') {
            [PSCustomObject]@{
                Side     = 'Machine'
                CSE_GUID = $Matches[1]
                Tool_GUID = $Matches[2]
            }
        }
    } | Format-Table -AutoSize

Write-Host "=== User CSE ==="
$gpcObj.gPCUserExtensionNames -split '\]\[' |
    ForEach-Object {
        $entry = $_ -replace '^\[' -replace '\]$'
        if ($entry -match '^\{([^}]+)\}\{([^}]+)\}$') {
            [PSCustomObject]@{
                Side      = 'User'
                CSE_GUID  = $Matches[1]
                Tool_GUID = $Matches[2]
            }
        }
    } | Format-Table -AutoSize

=== Machine CSE ===
Side    CSE_GUID                               Tool_GUID
----    --------                               ---------
Machine 35378EAC-683F-11D2-A89A-00C04FBBCFA2  53D6AB1B-2488-11D1-A28C-00C04FB94F17
Machine 827D319E-6EAC-11D2-A4EA-00C04F79F83A  803E14A0-B4FB-11D0-A0D0-00A0C90F574B

=== User CSE ===
Side    CSE_GUID                               Tool_GUID
----    --------                               ---------
User    35378EAC-683F-11D2-A89A-00C04FBBCFA2  53D6AB1B-2488-11D1-A28C-00C04FB94F17

Impact sur les performances¶

Une GPO qui référence de nombreuses CSE force gpsvc à les invoquer toutes, même si elles n'ont que peu de paramètres à appliquer. En pratique, cela recommande de :

• Créer des GPO à responsabilité unique (une GPO = une fonction)
• Éviter les GPO "fourre-tout" qui mélangent sécurité, registre, scripts et préférences
• Désactiver la partie Machine ou Utilisateur (flags = 1 ou flags = 2) quand une GPO ne configure qu'un seul côté

Références croisées¶