Pack concerné : windows-by-WinRM__shinken

Versions : V02.08.00 — script Configure-Host.ps1 V02.08.00

Pour superviser un parc important, ou si vous avez besoin de maîtriser finement la configuration appliquée et déployée, consultez la page Configuration centralisée par GPO d'un parc Windows (Active Directory) pour le pack windows-by-WinRM__shinken

Conseil : même si vous devez équiper un parc entier :

• Vous pouvez passer par cette page pour valider le fonctionnement sur une machine de test.
• Vous passerez ensuite à la configuration par domaine, qui offre une gestion centralisée, contrôlable et révocable.

N'utilisez pas le compte Administrateur pour la supervision. Il fonctionnerait (il a tous les droits), mais c'est une mauvaise pratique de sécurité. Créez un compte dédié : c'est exactement ce que fait le script.

Ce prérequis s'applique aux deux méthodes, script compris. Le script vérifie la langue à son étape 1 et s'arrête immédiatement si aucune n'est présente : rien n'est configuré dans ce cas. Il n'installe pas la langue lui-même, car la méthode d'installation dépend de la version de Windows et nécessite parfois le média d'installation.

Get-WinUserLanguageList

LanguageTag     : en-US
Autonym         : English (United States)
EnglishName     : English
LocalizedName   : English (United States)
ScriptName      : Latin
InputMethodTips : {0409:0001040C}
Spellchecking   : True
Handwriting     : False

Sur Windows 10, Windows 11 et Windows Server 2025 uniquement, la commande Get-InstalledLanguage donne une vue plus lisible des langues installées sur la machine :

Language  Language Packs  Language Features
--------  --------------  -----------------
en-US     LpCab, LXP      BasicTyping, Handwriting, Speech, TextToSpeech, OCR
fr-FR     LpCab, LXP      BasicTyping, Handwriting, Speech, TextToSpeech, OCR

Elle n'existe pas sur Windows Server 2022, 2019, 2016 et 2012 R2 : utilisez Get-WinUserLanguageList sur ces versions.

Seul le code de langue compte (en-US ou fr-FR). Les fonctionnalités listées dans la colonne Language Features — BasicTyping, Handwriting, Speech, TextToSpeech, OCR — ne sont pas requises par le pack : elles apparaissent parce qu'une installation par l'interface graphique les ajoute par défaut. L'option -ExcludeFeatures de Install-Language permet d'ailleurs de toutes les omettre.

La langue choisie n'influence pas l'affichage des résultats de supervision. Elle conditionne uniquement le bon fonctionnement de la sonde.

Get-Service WinRM

Status   Name    DisplayName
------   ----    -----------
Running  WinRM   Gestion à distance de Windows (Gest...

Windows 10 et Windows 11 uniquement — le service n'est pas en démarrage automatique par défaut. Corrigez-le :

Set-Service -Name WinRM -StartupType Automatic

Pour une seule machine, le plus simple est de télécharger le script directement depuis cette page (lien à l'étape 1), puis de le copier sur la machine à superviser. Les méthodes ci-dessous concernent le déploiement sur plusieurs machines.

scp supervised-host/Configure-Host.ps1 Administrateur@<IP_HOST>:C:/Users/Administrateur/

Set-ExecutionPolicy Unrestricted -Scope Process

Toutes les commandes doivent être exécutées dans un PowerShell lancé en tant qu'administrateur.

Le mode domaine est détecté automatiquement : inutile de préciser -Domain sur une machine jointe au domaine. Utilisez -Local uniquement pour forcer la création d'un compte local sur une machine pourtant jointe au domaine.

-Domain et -Local sont mutuellement exclusifs : les indiquer ensemble arrête le script.

Identifiants d'annuaire — le script utilise votre session courante si elle a les droits d'écriture dans l'annuaire, et vous les demande en mode -Interactive. Ajoutez -DomainCredential $cred uniquement pour un lancement automatisé (à distance ou par tâche planifiée), où aucune invite ne doit bloquer.

Mot de passe : le script accepte un SecureString (recommandé) ou une simple chaîne de caractères. Pour préparer un SecureString :

$secPass = ConvertTo-SecureString "VotreMotDePasse" -AsPlainText -Force

.\Configure-Host.ps1 -Default

Changez impérativement le mot de passe par défaut. Le mode par défaut est fait pour tester le pack, pas pour un environnement exposé.

-Default ignore les paramètres de compte, d'authentification et de services. La commande .\Configure-Host.ps1 -Default -UserName mon_compte crée le compte shinken_user, pas mon_compte, et aucune erreur n'est affichée. Pour choisir vos propres valeurs, utilisez le mode paramétré.

.\Configure-Host.ps1 -Interactive

$secPass = ConvertTo-SecureString "P@ssw0rd!" -AsPlainText -Force
.\Configure-Host.ps1 -UserName "shinken_user" -Password $secPass -Negotiate true -Basic false -AllowUnencrypted false

$secPass = ConvertTo-SecureString "P@ssw0rd!" -AsPlainText -Force
.\Configure-Host.ps1 -ADUserName "shinken_user" -CreateADUser -ADGroupName "GRP_SHINKEN" -CreateADGroup -Password $secPass

.\Configure-Host.ps1 -ADUserName "shinken_user" -ADGroupName "GRP_SHINKEN"

Cette page couvre la configuration d'UNE machine. Pour équiper un parc entier via stratégie de groupe (GPO), voir la page dédiée au déploiement en domaine.

Pourquoi un groupe ? Les droits sont posés sur le groupe, pas sur le compte. Changer de compte de supervision plus tard ne demande donc aucune reprise sur les machines : il suffit de placer le nouveau compte dans le groupe.

Sur une machine Active Directory, le redémarrage n'est pas nécessaire. Passez directement à la vérification.

Malgré son nom, -SkipServicePermissions ne désactive pas la configuration des services : il la limite aux trois services critiques, qui restent accordés dans tous les cas.

.\Configure-Host.ps1 -Default -PasswordNeverExpires

$secPass = ConvertTo-SecureString "P@ssw0rd!" -AsPlainText -Force
.\Configure-Host.ps1 -UserName "shinken_user" -Password $secPass -PasswordNeverExpires

En mode -Interactive, la question vous est posée directement ; le commutateur n'est alors pas nécessaire.

Si le mot de passe a déjà expiré, désactiver l'expiration ne suffit pas à débloquer le compte : il faut réinitialiser le mot de passe, puis désactiver l'expiration.

Étape non nécessaire sur les machines Active Directory.

Cette méthode est l'équivalent exact de ce que fait le script. Suivez-la si vous préférez maîtriser chaque étape, ou si le script ne convient pas à votre environnement. Si vous avez utilisé la Méthode A, passez directement à la vérification.

winrm quickconfig

C:\Users\Administrateur> winrm quickconfig

WinRM n'est pas configuré pour la gestion à distance de cet ordinateur.
Les modifications suivantes doivent être effectuées :

Créez un écouteur WinRM sur HTTP://* pour accepter les demandes de la gestion
des services Web sur toutes les adresses IP de cet ordinateur.

Activez l'exception de pare-feu WinRM.
Configurez LocalAccountTokenFilterPolicy pour attribuer des droits
d'administration à distance à des utilisateurs locaux.

Effectuer ces modifications [y/n] ? y

WinRM a été mis à jour pour la gestion à distance.

Windows 10 / 11 — piège fréquent : le réseau en profil « Public ».

Si votre carte réseau est en profil Public (le défaut), la configuration du pare-feu échoue silencieusement:

WSManFault
 Message = L'exception de pare-feu WinRM ne fonctionnera pas car l'un des types
 de connexion réseau de cet ordinateur est défini à Public. Changez le type de
 connexion réseau en Domaine ou Privé, puis recommencez.

Numéro d'erreur : -2144108183 0x80338169

Solution : basculez la connexion en profil Privé ou Domaine, puis relancez winrm quickconfig.

Si vous choisissez Basic, l'authentification n'apporte aucun chiffrement. Il faut donc autoriser explicitement les communications non chiffrées :

winrm set winrm/config/service '@{AllowUnencrypted="true"}'

N'utilisez Basic que si aucun mode plus sécurisé n'est disponible sur le système. HTTPS n'est pas supporté par le pack à ce jour.

& {
param(
   [Parameter(Mandatory=$true)]
   [string]$UserName,

   [Parameter(Mandatory=$true)]
   [string]$Password
)
net user $UserName $Password /ADD
}

À faire uniquement si Get-WinUserLanguageList (voir Prérequis) n'a retourné ni en-US ni fr-FR.

# Installer l'anglais
Install-Language -Language en-US -ExcludeFeatures

# Installer le français
Install-Language -Language fr-FR -ExcludeFeatures

Cette opération peut prendre 5 à 30 minutes selon votre machine et la charge des serveurs Microsoft.

DISM.exe /Online /add-capability /CapabilityName:Language.Basic~~~en-US~0.0.1.0

Commande non disponible sur Windows Server 2012 R2.

& {

param(
   [Parameter(Mandatory=$true)]
   [string]$UserName,

   [Parameter(Mandatory=$true)]
   [string]$Password
)

$LangCode = "en-US", "fr-FR"

$Computer = $env:COMPUTERNAME
$SID = (Get-WmiObject Win32_UserAccount -Filter "Name='$UserName' AND Domain='$Computer'").SID
if (-not $SID) { throw "Impossible de récupérer le SID pour $UserName" }

# Récupération du profil
$UserProfile = Get-CimInstance Win32_UserProfile | Where-Object SID -eq $SID

# Le profil peut ne pas exister si l'utilisateur a été créé mais ne s'est jamais connecté.
# Tentative de connexion à l'utilisateur ...
if (-not $UserProfile) {
   $SecurePassword = ConvertTo-SecureString $Password -AsPlainText -Force
   $Credential = New-Object System.Management.Automation.PSCredential ($UserName, $SecurePassword)
   try {
       Start-Process -FilePath "whoami.exe" -Credential $Credential -WindowStyle Hidden -Wait
   } catch {
       Write-Host "Impossible de lancer un logon test pour $UserName ($_)" -ForegroundColor Red
   }

   # Récupération à nouveau du profil
   $UserProfile = Get-CimInstance Win32_UserProfile | Where-Object SID -eq $SID
}

if (-not $UserProfile) { throw "Profil introuvable pour $UserName" }

$HivePath = Join-Path $UserProfile.LocalPath "NTUSER.DAT"
if (-not (Test-Path $HivePath)) { throw "Profil non initialisé (NTUSER.DAT introuvable) : $HivePath" }

$regRelative = "Control Panel\Desktop"
$valueName = "PreferredUILanguages"

$IsLoaded = Test-Path "Registry::HKEY_USERS\$SID"
if ($IsLoaded) {
   $fullPath = "Registry::HKEY_USERS\$SID\$regRelative"
   if (-not (Test-Path $fullPath)) { New-Item -Path $fullPath -Force | Out-Null }
   if (-not (Get-ItemProperty -Path $fullPath -Name $valueName -ErrorAction SilentlyContinue)) {
       New-ItemProperty -Path $fullPath -Name $valueName -Value $LangCode -PropertyType MultiString -Force | Out-Null
   } else {
       Set-ItemProperty -Path $fullPath -Name $valueName -Value $LangCode
   }
} else {
   Write-Host "Utilisateur non connecté. Chargement de la ruche..." -ForegroundColor Gray
   reg load "HKU\TempHive" $HivePath | Out-Null
   try {
       $tempPath = "Registry::HKEY_USERS\TempHive\$regRelative"
       if (-not (Test-Path $tempPath)) { New-Item -Path $tempPath -Force | Out-Null }
       if (-not (Get-ItemProperty -Path $tempPath -Name $valueName -ErrorAction SilentlyContinue)) {
           New-ItemProperty -Path $tempPath -Name $valueName -Value $LangCode -PropertyType MultiString -Force | Out-Null
       } else {
           Set-ItemProperty -Path $tempPath -Name $valueName -Value $LangCode
       }
   } finally {
       reg unload "HKU\TempHive" | Out-Null
       Write-Host "Ruche déchargée." -ForegroundColor Gray
   }
}

Write-Host "Langue préférée utilisateur définie sur $LangCode (REG_MULTI_SZ)." -ForegroundColor Green
}

& {
param([Parameter(Mandatory=$true)][string]$UserName)

net localgroup "Utilisateurs de gestion à distance" $UserName /ADD
net localgroup "Utilisateurs de l’Analyseur de performances" $UserName /ADD
net localgroup "Lecteurs des journaux d’événements" $UserName /ADD
}

& {
param([Parameter(Mandatory=$true)][string]$UserName)

net localgroup "Remote Management Users" $UserName /ADD
net localgroup "Performance Monitor Users" $UserName /ADD
net localgroup "Event Log Readers" $UserName /ADD
}

Piège du copier-coller — l'apostrophe typographique.

Sur un Windows en français, ce groupe s'écrit avec une apostrophe typographique ’ ( U+2019 ), et non avec l'apostrophe droite ' ( U+0027 ) de la touche 4 du clavier. Retaper la commande à la main produit donc un nom que Windows ne reconnaît pas :

L’erreur système 1376 s’est produite.
Le groupe local spécifié n’existe pas.

Trois façons de s'en sortir :

• Copiez-collez la commande ci-dessus : elle contient désormais la bonne apostrophe ;
• ou saisissez l'apostrophe avec ALT + 0146 au pavé numérique ( elle est différente de celle de la touche 4 ) ;
• ou utilisez le nom anglais du groupe, qui ne contient aucune apostrophe : net localgroup "Performance Monitor Users" $UserName /ADD.

Pour lire le nom exact tel que Windows le stocke :

(Get-LocalGroup | Where-Object Name -like "*Analyseur*").Name

winrm configSDDL default

& {

param(
   [Parameter(Mandatory = $true)][string]$UserName
)

$GENERIC_READ = 0x80000000
$GENERIC_EXECUTE = 0x20000000

$user_sid = (New-Object -TypeName System.Security.Principal.NTAccount -ArgumentList $UserName).Translate([System.Security.Principal.SecurityIdentifier])

# Récupère le SDDL existant de l'écouteur WinRM
$sddl = (Get-Item -Path WSMan:\localhost\Service\RootSDDL).Value

# Convertit la chaîne SDDL en objet SecurityDescriptor
$sd = New-Object -TypeName System.Security.AccessControl.CommonSecurityDescriptor -ArgumentList $false, $false, $sddl

# Applique une nouvelle DACL à l'objet SecurityDescriptor
$sd.DiscretionaryAcl.AddAccess(
   [System.Security.AccessControl.AccessControlType]::Allow,
   $user_sid,
   ($GENERIC_READ -bor $GENERIC_EXECUTE),
   [System.Security.AccessControl.InheritanceFlags]::None,
   [System.Security.AccessControl.PropagationFlags]::None
)

# Récupère la chaîne SDDL depuis l'objet modifié
$new_sddl = $sd.GetSddlForm([System.Security.AccessControl.AccessControlSections]::All)

# Applique le nouveau SDDL à l'écouteur WinRM
Set-Item -Path WSMan:\localhost\Service\RootSDDL -Value $new_sddl -Force
Write-Host "Permissions de 'Lecture' et 'Exécution' WinRM ajoutées pour l'utilisateur $UserName" -ForegroundColor Green
}

Cette section s'applique aussi aux machines en Active Directory. Le script Configure-Host.ps1 pose ces permissions dans tous les cas ( étapes 6 et 7 de son déroulé ) : en domaine, il les accorde au groupe de supervision au lieu du compte. Si vous suivez la méthode manuelle sur une machine du domaine, ne sautez donc pas cette étape.

wmimgmt.msc

&{

Param (
   [parameter(Mandatory=$true)][string] $username,
   [bool] $allowInherit = $false,
   [bool] $deny = $false,
   [string] $computerName = ".",
   [System.Management.Automation.PSCredential] $credential = $null
)

$namespaces = @("root\cimv2", "root\standardcimv2")
$permissions = @("Enable", "RemoteAccess")

foreach ($namespace in $namespaces) {
   Write-Host "Configuration des permissions pour le namespace: $namespace"
   $ErrorActionPreference = "Stop"

   Function Get-AccessMaskFromPermission($permissions) {
       $WBEM_ENABLE            = 1
       $WBEM_METHOD_EXECUTE    = 2
       $WBEM_FULL_WRITE_REP    = 4
       $WBEM_PARTIAL_WRITE_REP = 8
       $WBEM_WRITE_PROVIDER    = 0x10
       $WBEM_REMOTE_ACCESS     = 0x20
       $READ_CONTROL           = 0x20000
       $WRITE_DAC              = 0x40000

       $WBEM_RIGHTS_FLAGS = $WBEM_ENABLE,$WBEM_METHOD_EXECUTE,$WBEM_FULL_WRITE_REP,`
           $WBEM_PARTIAL_WRITE_REP,$WBEM_WRITE_PROVIDER,$WBEM_REMOTE_ACCESS,`
           $READ_CONTROL,$WRITE_DAC

       $WBEM_RIGHTS_STRINGS = "Enable","MethodExecute","FullWrite","PartialWrite",`
           "ProviderWrite","RemoteAccess","ReadSecurity","WriteSecurity"

       $permissionTable = @{}
       for ($i = 0; $i -lt $WBEM_RIGHTS_FLAGS.Length; $i++) {
           $permissionTable.Add($WBEM_RIGHTS_STRINGS[$i].ToLower(), $WBEM_RIGHTS_FLAGS[$i])
       }

       $accessMask = 0
       foreach ($permission in $permissions) {
           if (-not $permissionTable.ContainsKey($permission.ToLower())) {
               throw "Unknown permission: $permission`nValid permissions: $($permissionTable.Keys)"
           }
           $accessMask += $permissionTable[$permission.ToLower()]
       }
       $accessMask
   }

   if ($PSBoundParameters.ContainsKey("Credential")) {
       $remoteparams = @{ComputerName=$computerName;Credential=$credential}
   } else {
       $remoteparams = @{}
   }

   $invokeparams = @{Namespace=$namespace;Path="__systemsecurity=@"} + $remoteParams
   $output = Invoke-WmiMethod @invokeparams -Name GetSecurityDescriptor
   if ($output.ReturnValue -ne 0) {
       throw "GetSecurityDescriptor failed: $($output.ReturnValue)"
   }

   $acl = $output.Descriptor
   $OBJECT_INHERIT_ACE_FLAG = 0x1
   $CONTAINER_INHERIT_ACE_FLAG = 0x2
   $computerName = (Get-WmiObject @remoteparams Win32_ComputerSystem).Name

   if ($username.Contains('\')) {
       $domainaccount = $username.Split('\')
       $domain = $domainaccount[0]
       if (($domain -eq ".") -or ($domain -eq "BUILTIN")) {
           $domain = $computerName
       }
       $accountname = $domainaccount[1]
   } elseif ($username.Contains('@')) {
       $domainaccount = $username.Split('@')
       $domain = $domainaccount[1].Split('.')[0]
       $accountname = $domainaccount[0]
   } else {
       $domain = $computerName
       $accountname = $username
   }

   $getparams = @{Class="Win32_Account";Filter="Domain='$domain' and Name='$accountname'"} + $remoteParams
   $win32account = Get-WmiObject @getparams
   if ($win32account -eq $null) {
       throw "Account was not found: $username"
   }

   $accessMask = Get-AccessMaskFromPermission($permissions)
   $ace = (New-Object System.Management.ManagementClass("win32_Ace")).CreateInstance()
   $ace.AccessMask = $accessMask

   if ($allowInherit) {
       $ace.AceFlags = $OBJECT_INHERIT_ACE_FLAG + $CONTAINER_INHERIT_ACE_FLAG
   } else {
       $ace.AceFlags = 0
   }

   $trustee = (New-Object System.Management.ManagementClass("win32_Trustee")).CreateInstance()
   $trustee.SidString = $win32account.Sid
   $ace.Trustee = $trustee

   $ACCESS_ALLOWED_ACE_TYPE = 0x0
   $ACCESS_DENIED_ACE_TYPE = 0x1

   if ($deny) {
       $ace.AceType = $ACCESS_DENIED_ACE_TYPE
   } else {
       $ace.AceType = $ACCESS_ALLOWED_ACE_TYPE
   }
   $acl.DACL += $ace.psobject.immediateBaseObject

   $setparams = @{Name="SetSecurityDescriptor";ArgumentList=$acl.psobject.immediateBaseObject} + $invokeParams
   $output = Invoke-WmiMethod @setparams
   if ($output.ReturnValue -ne 0) {
       throw "SetSecurityDescriptor failed: $($output.ReturnValue)"
   }

   Write-Host "Permissions configurées avec succès pour $username sur $namespace"
}

Write-Host "Configuration terminée pour tous les namespaces"

}

&{

Param (
   [parameter(Mandatory=$true)][string] $UserName
)

$sid = (New-Object System.Security.Principal.NTAccount($UserName)).Translate([System.Security.Principal.SecurityIdentifier]).Value
$currentSddl = & sc.exe sdshow w32time
# Ajoute les droits suivants à l'utilisateur
#  CC – SERVICE_QUERY_CONFIG
#  LC – SERVICE_QUERY_STATUS
#  LO – SERVICE_INTERROGATE
$newAce = "(A;;CCLCLO;;;${sid})"
$newSddl = $currentSddl + $newAce

sc.exe sdset w32time "$newSddl"

Restart-Service w32time

}

&{

Param (
   [parameter(Mandatory=$true)][string] $UserName
)
   try {
       $Path = "HKLM:\SYSTEM\CurrentControlSet\Services\EventLog\Security"
       $acl = Get-Acl $Path
       $rule = New-Object System.Security.AccessControl.RegistryAccessRule(
           $UserName,
           "ReadKey",
           "Allow"
       )
       $acl.AddAccessRule($rule)
       Set-Acl $Path $acl
       Write-Host " Droits Registre appliqués." -ForegroundColor Green
   } catch {
       Write-Host " Erreur permissions EventLog Security: $_" -ForegroundColor Red
       throw
   }
}

Ces deux tests s'effectuent sur la machine Windows à superviser, dans un PowerShell administrateur.

Get-NetFirewallRule -Name "WINRM-HTTP-In-TCP"

Enable-NetFirewallRule -Name "WINRM-HTTP-In-TCP"

# Si vous avez configuré Negotiate (recommandé)
Test-WSMan localhost -Credential (Get-Credential) -Authentication Negotiate

# Si vous avez configuré Basic
Test-WSMan localhost -Credential (Get-Credential) -Authentication Basic

Pour les erreurs remontées par les checks une fois la supervision en place, consultez la page Erreurs du pack windows-by-WinRM__shinken.

Sans -Domain ni -Local, le mode est détecté automatiquement.