Page History

Afin de configurer des postes Windows d'un domaine ( Active Directory ), voir la page Configuration du Windows supervisé dans un Domaine ( Active Directory ) pour le pack windows-by-WinRM__shinken

• Windows Server 2025
• Windows Server 2022
• Windows Server 2019
• Windows Server 2016
• Windows Server 2012 R2
• Windows 11
• Windows 10

Image Added

Les configurations suivantes sont destinées à des serveurs Windows configurés en "groupe de travail" ( Workgroup ).

La configuration pour un serveur Windows configuré par "domaine" ( Active Directory ) diffère partiellement ( Voir la page Configuration du Windows supervisé dans un Domaine ( Active Directory ) pour le pack windows-by-WinRM__shinken ).

Toutes les commandes ci-dessous doivent être exécutées dans un terminal PowerShell lancé en mode administrateur ( sauf mention contraire )

Get-Service WinRM

C:\Users\Administrateur> Get-Service WinRM

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

Sur Windows 11 et Windows 10, il est nécessaire de configurer le démarrage automatique de WinRM :

Set-Service -Name WinRM -StartupType Automatic

Il doit être exécuté sur chaque poste Windows à superviser.

Avant d’utiliser ce script, lire attentivement les points recommandés suivants :

• Lecture préalable recommandée

  • Le script modifie la configuration système ( WinRM, WMI, services, permissions ).

• Environnement de test recommandé

  • Exécutez d’abord le script dans un environnement de test ou sur un serveur non critique.

  • Ne déployez en production qu’après validation de son bon fonctionnement.

• Privilèges administratifs requis

  • Le script doit être lancé en tant qu’administrateur.

  • Un manque de droits entraînera des erreurs ou une configuration partielle.

• Impact sécurité

  • L’activation de WinRM et l’usage éventuel de l’authentification Basic/AllowUnencrypted peuvent exposer des risques de sécurité.

  • Vérifiez vos politiques de sécurité internes avant de déployer ce type de configuration.

• Adaptabilité du script

  • Certaines parties sont spécifiques à Windows 10, Windows 11, Windows Server 2025.

  • Pour d’autres versions de Windows, l’installation des langues devra être fait manuellement.

• Responsabilité

  • L’exécution reste sous la responsabilité de l’administrateur.

Rappel : le script nécessite les droits administrateurs pour l’exécution

Configure-Host.ps1

Les méthodes de déploiement du script vont dépendre de votre environnement et de vos outils ( SSH, FTP, cloud, docker, Ansible, Terraform ... ) .

Avant de déployer le script de configuration sur plusieurs serveurs Windows à superviser, il est fortement conseillé de tester le script de configuration sur UN serveur Windows, pour valider son comportement dans votre environnement.

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

Il est nécessaire pour les hôtes supervisés d'avoir d'installé au moins une des langues suivantes, pour le bon fonctionnement de la sonde : 

• Français ( fr-FR )
• Anglais ( en-US )

La commande suivante permet d'afficher les langues installées sur votre machine : 

Get-InstalledLanguage

Un résultat similaire à celui-la sera obtenu : 

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

Alors, si vos Windows à superviser ont au moins une des langues nécessaires, passer à l'étape suivante.

Sinon, voici quelques outils pour installer de nouvelles langues :

Ici, la langue configurée n'a pas d'impact sur la traduction et l'affichage des résultats générés par la sonde, mais a un impact sur le bon fonctionnement.

Pour les Windows ci-dessous, il est possible d'exécuter la commande suivante afin d'installer une langue :

• Windows 11
• Windows 10
• Windows Server 2025

# Installer la langue en Anglais

.\Configure-Host.ps1 -Help

.\Configure-Host.ps1 -Default

La configuration par défaut est une bonne façon de tester le pack, mais il est recommandé de changer les paramètres d'authentification pour des environnements exposés.

.\Configure-Host.ps1 -Interactive

Image Added

.\Configure-Host.ps1 -UserName MyNewUser -Password MyNewPassword -Negotiate true -Basic false -AllowUnencrypted false

Image Added

Set-ExecutionPolicy Unrestricted -Scope Process

Les tests suivants sont à effectuer sur le poste Windows à superviser.

Une fois ces deux tests validés, la configuration du poste Windows est terminée et il est prêt à être supervisé.

L'étape suivante est de choisir, d'accrocher et de paramétrer les modèles d'hôtes fournis dans le pack ( Voir la page Modèles d'hôtes du pack windows-by-WinRM__shinken ).

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.

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

Exception de pare-feu WinRM activée.
LocalAccountTokenFilterPolicy configuré pour attribuer des droits d'administration à distance à des utilisateurs locaux.

Attention, Sur Windows 11 et Windows 10 l'hôte a besoin d'être en réseau privé et non public qui est par défaut. Sinon la configuration sera bloquée et non appliquée :

C:\Users\Administrateur> winrm quickconfig

Le service WinRM est déjà en cours d’exécution sur cet ordinateur.
WSManFault
    Message
        ProviderFault
            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
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.

Sur Windows 11 et Windows 10, il est necessaire de configurer le démarrage automatique de WinRM :

Set-Service -Name WinRM -StartupType Automatic

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

L’utilisation du protocole « Basic » n’est pas recommandée lorsque des modes d’authentification plus sécurisés sont disponibles sur le système.

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

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

& {
param(
    [Parameter(Mandatory=$true)]
    [string]$UserName,
 
    [Parameter(Mandatory=$true)]
    [string]$Password
)
net user $Username $Password /ADD

}

Get-WinUserLanguageList

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

LanguageTag     : fr-FR
Autonym         : Français (France)
EnglishName     : French
LocalizedName   : French (France)
ScriptName      : Latin
InputMethodTips : {040C:0000040C}
Spellchecking   : True
Handwriting     : False

Image Added

Image Added

Image Added

Image Added

Image AddedImage Added

Cette commande n'est disponible que sur Windows 10, Windows 11 et Windows Server 2025.
Dans les autres cas, la langue devra être téléchargée manuellement par interface.

# Installer la langue en Anglais
Install-Language -Language en-US -ExcludeFeatures

# Installer la langue en Francais
Install-Language -Language fr-FR -ExcludeFeatures

Il est nécessaire de se connecter au nouveau compte de supervision créé pour changer la langue de l'utilisateur.

Image Added

& {
 
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" }
 
# Recupé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 jamais été connecté.
# Tentative de connection à 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
}

Ensuite, il est nécessaire de se déconnecter puis se reconnecter au nouvel utilisateur afin de correctement appliquer le changement de langue.

Il est possible que la commande "net localgroup "Utilisateurs de l’Analyseur de performances" $UserName /ADD" ne fonctionne pas lors d'un copier-coller.

Il y a un bug avec le terminal PowerShell sur le copier-coller qui ne retranscrira pas le symbole apostrophe ’ lorsque l'action "coller" est déclenché avec un clic droit dans le terminal.
Il faut utiliser le raccourci "CTRL+V" afin de coller correctement la commande
Sinon, il est possible de générer le caractère spécial apostrophe ’ avec le raccourci "ALT + 0146".  ( Différent de l'apostrophe de la touche 4 ).

Exemple du bug du copier-coller dans un terminal PowerShell Administrateur où l'apostrophe n'est pas retranscrite :

winrm configSDDL default

Image Added

& {

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])

# get the existing SDDL of the WinRM listener
$sddl = (Get-Item -Path WSMan:\localhost\Service\RootSDDL).Value

# convert the SDDL string to a SecurityDescriptor object
$sd = New-Object -TypeName System.Security.AccessControl.CommonSecurityDescriptor -ArgumentList $false, $false, $sddl

# apply a new DACL to the SecurityDescriptor object
$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
)

# get the SDDL string from the changed SecurityDescriptor object
$new_sddl = $sd.GetSddlForm([System.Security.AccessControl.AccessControlSections]::All)

# apply the new SDDL to the WinRM listener
Set-Item -Path WSMan:\localhost\Service\RootSDDL -Value $new_sddl -Force
Write-Host "Permissions de 'Lecture' et 'Execution' WinRM ajoutées pour l'utilisateur $UserName" -ForegroundColor Green
}

Cette section n'est pas nécessaire si les machines supervisées sont configurées avec un Active Directory.

wmimgmt.msc

Image Added

Image Added

Image Added

Image Added

&{

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 = 8WmiNamespaceSecurity.ps1
# Example: Set-WmiNamespaceSecurity root/cimv2 add steve Enable,RemoteAccess

Param ( [parameter(Mandatory=$true,Position=0)][string] $namespace,
    [parameter(Mandatory=$true,Position=1)][string] $operation,
    [parameter(Mandatory=$true,Position=2)][string] $account,
    [parameter(Position=3)][string[]] $permissions = $null,
    [bool] $allowInherit = $false,
    [bool] $deny = $false,
    [string] $computerName = ".",
    [System.Management.Automation.PSCredential] $credential = $null)

Process {
    $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
        $WBEM_RIGHTWRITE_SUBSCRIBEPROVIDER = 0x400x10
        $WBEM_RIGHTREMOTE_PUBLISHACCESS = 0x800x20
        $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=$computer$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 ($account$username.Contains('\')) {
        $domainaccount = $account$username.Split('\')
        $domain = $domainaccount[0]
        if (($domain -eq ".") -or ($domain -eq "BUILTIN")) {
            $domain = $computerName
        }
        $accountname = $domainaccount[1]
    } elseif ($account$username.Contains('@')) {
        $domainaccount = $account$username.Split('@')
        $domain = $domainaccount[1].Split('.')[0]
        $accountname = $domainaccount[0]
    } else {
        $domain = $computerName
        $accountname = $account$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: $account"
    }

    switch ($operation) {' and Name='$accountname'"} + $remoteParams
    $win32account =   "add" {
       Get-WmiObject @getparams
     if ($permissions$win32account -eq $null) {
                throw "-PermissionsAccount mustwas benot specified for an add operationfound: $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) }{
        "delete" {
            if ($permissions -ne $null) {
               throw "Permissions cannot be specified for a delete operation"
            }

            [System.Management.ManagementBaseObject[]]$newDACL = @()
            foreach ($ace in $acl.DACL) {
                if ($ace.Trustee.SidString -ne $win32account.Sid) {
          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  $newDACL += $ace.psobject.immediateBaseObject= "HKLM:\SYSTEM\CurrentControlSet\Services\EventLog\Security"
        $acl =       }Get-Acl $Path
        $rule =   }New-Object System.Security.AccessControl.RegistryAccessRule(
            $acl.DACL = $newDACL.psobject.immediateBaseObject
$UserName,
            }"ReadKey",
         default {   "Allow"
        )
    throw "Unknown operation: $operation`nAllowed operations: add delete"
 $acl.AddAccessRule($rule)
        Set-Acl $Path }$acl
    }

    $setparams = @{Name="SetSecurityDescriptor";ArgumentList=$acl.psobject.immediateBaseObject} + $invokeParams
Write-Host "      Droits $outputRegistre =appliqués." Invoke-WmiMethodForegroundColor @setparamsGreen
    if ($output.ReturnValue -ne 0)  } catch {
        throwWrite-Host "SetSecurityDescriptor failed: $($output.ReturnValue)"
    }

}


'@ | Set-Content $script_name

Les tests suivants sont à effectuer sur le poste Windows à superviser.

Une fois ces deux tests validés, la configuration du poste Windows est terminée et il est prêt à être supervisé.

L'étape suivante est de choisir, d'accrocher et de paramétrer les modèles d'hôtes fournis dans le pack ( Voir la page Modèles d'hôtes du pack windows-by-WinRM__shinken ).

$user = "mon_utilisateur"

$sid = (New-Object System.Security.Principal.NTAccount($user)).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

Remplacer ici "mon_utilisateur"