Protéger les informations d’identification de domaine dérivées avec Credential Guard

Article
04/01/2016

Introduite dans Windows 10 Entreprise, la fonctionnalité Credential Guard utilise la sécurité basée sur la virtualisation pour isoler les secrets afin que les logiciels système privilégiés puissent y accéder. Un accès non autorisé à ces secrets peut entraîner des attaques de vol d’informations d’identification, « pass-the-hach » ou « pass-the-ticket » par exemple.

Credential Guard offre les fonctionnalités et solutions suivantes :

Sécurité matérielle Credential Guard renforce la sécurité des informations d’identification de domaine dérivées en tirant parti des fonctionnalités de sécurité de plateforme, notamment le démarrage sécurisé et la virtualisation.
Sécurité basée sur la virtualisation Les services Windows qui gèrent des informations d’identification de domaine dérivées et d’autres secrets sont exécutés dans un environnement protégé, isolé du système d’exploitation en cours d’exécution.
Meilleure protection contre les menaces persistantes avancées La sécurisation des informations d’identification de domaine dérivées utilisant la sécurité basée sur la virtualisation bloque les techniques d’attaque par vol des informations d’identification et les outils utilisés dans de nombreuses attaques ciblées. Les programmes malveillants exécutés dans le système d’exploitation avec des privilèges administratifs ne peuvent pas extraire les secrets protégés par la sécurité basée sur la virtualisation. Bien que Credential Guard permette de réduire efficacement les risques, les attaques de menace persistante sont susceptibles d’avoir recours à de nouvelles techniques. Par conséquent, nous vous recommandons également d’intégrer Device Guard et autres stratégies et architectures de sécurité.
Facilité de gestion Vous pouvez gérer Credential Guard à l’aide de la stratégie de groupe, de WMI, à partir d’une invite de commandes et de Windows PowerShell.

Fonctionnement

Credential Guard isole les secrets que les versions précédentes de Windows stockaient dans l’autorité de sécurité locale (LSA) à l’aide de la sécurité basée sur la virtualisation. Avant Windows 10, l’autorité de sécurité locale stockait les secrets utilisés par le système d’exploitation dans sa mémoire de processus. Avec Credential Guard, le processus de l’autorité de sécurité locale dans le système d’exploitation communique avec un nouveau composant appelé processus LSA isolé, qui stocke et protège ces secrets. Les données stockées par ce processus sont protégées à l’aide de la sécurité basée sur la virtualisation et ne sont pas accessibles au reste du système d’exploitation. L’autorité de sécurité locale utilise des appels de procédure distante pour communiquer avec le processus LSA isolé.

Pour des raisons de sécurité, le processus LSA isolé n’héberge aucun pilote de périphérique. Au lieu de cela, il héberge uniquement un petit sous-ensemble de fichiers binaires du système d’exploitation nécessaires à la sécurité, et rien d’autre. Tous ces fichiers binaires sont signés avec un certificat qui est approuvé par la sécurité basée sur la virtualisation, et ces signatures sont validées avant de lancer le fichier dans l’environnement protégé.

Credential Guard n’autorise ni les anciennes versions des protocoles d’authentification NTLM et Kerberos, ni les suites de chiffrement lors de l’utilisation d’informations d’identification dérivées par défaut, notamment NTLMv1, MS-CHAPv2 et les types de chiffrement Kerberos plus faibles comme DES.

Voici une vue d’ensemble sur la façon dont l’autorité de sécurité locale est isolée à l’aide de la sécurité basée sur la virtualisation :

Mt483740.credguard(fr-fr,VS.85).png

Fonctionnalités nouvelles et modifiées

Pour voir ce qui a été ajouté ou modifié dans Credential Guard, voir Nouveautés Credential Guard.

Configuration matérielle et logicielle requise

Le PC doit être conforme à la configuration matérielle et logicielle requise suivante pour utiliser Credential Guard :

Configuration requise	Description
Windows 10 Entreprise	Le PC doit exécuter Windows 10 Entreprise.
Version du microprogramme UEFI 2.3.1 ou supérieure et démarrage sécurisé	Pour vérifier que le microprogramme utilise la version UEFI 2.3.1 ou supérieure et le démarrage sécurisé, vous pouvez le comparer à la configuration requise System.Fundamentals.Firmware.CS.UEFISecureBoot.ConnectedStandby du Programme de compatibilité matérielle Windows.
Extensions de virtualisation	Les extensions de virtualisation suivantes sont requises pour prendre en charge la sécurité basée sur la virtualisation : Intel VT-x ou AMD-V Traduction d’adresse de second niveau
Architecture x64	Les fonctionnalités utilisées par la sécurité basée sur la virtualisation de l’hyperviseur Windows peuvent être exécutées sur un PC 64 bits uniquement.
Une IOMMU (unité de gestion de mémoire d’entrée/sortie) VT-d ou AMD Vi	Dans Windows 10, une IOMMU améliore la résilience du système contre les attaques de mémoire. ¹
Module de plateforme sécurisée (TPM) version 1.2 ou 2.0	Les modules TPM 1.2 et 2.0 fournissent une protection des clés de chiffrement stockées dans le microprogramme. Le module TPM 1.2 n’est pas pris en charge sur Windows 10 (build 10240), mais il l’est dans Windows 10, version 1511 (build 10586) et dans les versions ultérieures. Remarque Si vous ne disposez pas de module TPM installé, Credential Guard est toujours activé, mais les clés utilisées pour chiffrer Credential Guard ne sont pas protégées par le module TPM.
Processus de mise à jour de microprogramme sécurisé	Pour vérifier que le microprogramme est conforme au processus de mise à jour de microprogramme sécurisé, vous pouvez le comparer à la configuration requise System.Fundamentals.Firmware.UEFISecureBoot du Programme de compatibilité matérielle Windows.
Le microprogramme est mis à jour pour une implémentation MOR sécurisé	Credential Guard nécessite le MOR sécurisé pour empêcher certaines attaques de mémoire.
PC physique	Pour les PC exécutant Windows 10, vous ne pouvez pas exécuter Credential Guard sur un ordinateur virtuel.

¹ Si vous choisissez l’option Démarrage sécurisé et protection DMA dans le paramètre de stratégie de groupe, une IOMMU est nécessaire. L’option de stratégie de groupe Démarrage sécurisé active Credential Guard sur les appareils sans IOMMU.

Gérer Credential Guard

Credential Guard utilise les fonctionnalités de sécurité basée sur la virtualisation qui doivent être activées sur chaque PC avant de pouvoir l’utiliser.

Activer Credential Guard à l’aide de la stratégie de groupe

Vous pouvez utiliser la stratégie de groupe pour activer Credential Guard, car il ajoutera les fonctionnalités de sécurité basée sur la virtualisation pour vous.

À partir de la Console de gestion des stratégies de groupe, accédez à Configuration ordinateur > Modèles d’administration > Système > Device Guard.
Double-cliquez sur Activer la sécurité basée sur la virtualisation et sélectionnez l’option Activé.
Dans le champ Sélectionner le niveau de sécurité de plateforme, choisissez Démarrage sécurisé ou Démarrage sécurisé et protection DMA.
Dans le champ Configuration Credential Guard, cliquez sur Activé avec le verrouillage UEFI, puis cliquez sur OK. Si vous voulez être en mesure de désactiver Credential Guard à distance, choisissez Activé sans verrouillage.
Fermez la Console de gestion des stratégies de groupe.

Ajouter Credential Guard à une image

Si vous souhaitez ajouter Credential Guard à une image, vous pouvez le faire en ajoutant les fonctionnalités de sécurité basée sur la virtualisation, puis en activant Credential Guard.

Ajouter les fonctionnalités de sécurité basée sur la virtualisation

Vous devez tout d’abord ajouter les fonctionnalités de sécurité basée sur la virtualisation. Vous pouvez le faire en utilisant le panneau de configuration ou l’outil Gestion et maintenance des images de déploiement.

Remarque Si vous activez Credential Guard à l’aide d’une stratégie de groupe, ces étapes ne sont pas nécessaires. La stratégie de groupe installera les fonctionnalités pour vous.

Mt483740.wedge(fr-fr,VS.85).gif Ajouter les fonctionnalités de sécurité basée sur la virtualisation à l’aide de Programmes et fonctionnalités

Ouvrez le Panneau de configuration Programmes et fonctionnalités.
Cliquez sur Activer ou désactiver des fonctionnalités Windows.
Cochez la case Mode utilisateur isolé.
Accédez à Hyper-V -> Plateforme Hyper-V, puis cochez la case Hyperviseur Hyper-V.
Cliquez sur OK.

Mt483740.wedge(fr-fr,VS.85).gif Ajouter les fonctionnalités de sécurité basée sur la virtualisation à une image hors ligne à l’aide de DISM

Ouvrez une invite de commandes avec élévation de privilèges.

Ajoutez l’hyperviseur Hyper-V en exécutant la commande suivante :

dism /image:<WIM file name> /Enable-Feature /FeatureName:Microsoft-Hyper-V-Hypervisor

Ajoutez le mode utilisateur isolé en exécutant la commande suivante :

dism /image:<WIM file name> /Enable-Feature /FeatureName:IsolatedUserMode

Remarque

Vous pouvez également ajouter ces fonctionnalités à une image en ligne à l’aide de DISM ou du Gestionnaire de configuration.

Activer Credential Guard

Si vous n’utilisez pas de stratégie de groupe, vous pouvez activer Credential Guard à l’aide du Registre.

Mt483740.wedge(fr-fr,VS.85).gif Activer Credential Guard à l’aide du Registre

Ouvrez l’Éditeur du Registre.
Activez la sécurité basée sur la virtualisation :
- Accédez à HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\DeviceGuard.
- Ajoutez une nouvelle valeur DWORD nommée EnableVirtualizationBasedSecurity. Définissez la valeur de ce paramètre de Registre sur 1 pour activer la sécurité basée sur la virtualisation et sur 0 pour le désactiver.
- Ajoutez une nouvelle valeur DWORD nommée RequirePlatformSecurityFeatures. Définissez la valeur de ce paramètre de Registre sur 1 pour utiliser Démarrage sécurisé uniquement ou sur 2 pour utiliser Démarrage sécurité et protection DMA.
Activez Credential Guard :
- Accédez à HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\LSA.
- Ajoutez une nouvelle valeur DWORD nommée LsaCfgFlags. Définissez la valeur de ce paramètre de Registre sur 1 pour activer Credential Guard avec verrouillage UEFI, sur 2 pour activer Credential Guard sans verrouillage et sur 0 pour le désactiver.
Fermez l’Éditeur du Registre.

Remarque

Vous pouvez également activer Credential Guard en définissant les entrées de Registre dans le paramètre sans assistance FirstLogonCommands.

Supprimer Credential Guard

Si vous devez supprimer Credential Guard d’un PC, procédez comme suit :

Si vous avez utilisé une stratégie de groupe, désactivez le paramètre de stratégie de groupe utilisé pour activer Credential Guard (Configuration ordinateur -> Modèles d’administration -> Système -> Device Guard -> Activer la sécurité basée sur la virtualisation).
Supprimez le paramètre de Registre suivant : HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\DeviceGuard\LsaCfgFlags
Supprimez les variables EFI de Credential Guard à l’aide de BCDEdit.

Mt483740.wedge(fr-fr,VS.85).gif Supprimer les variables EFI de Credential Guard

À partir d’une invite de commandes avec élévation de privilèges, tapez les commandes suivantes :

mountvol X: /s
copy %WINDIR%\System32\SecConfig.efi X:\EFI\Microsoft\Boot\SecConfig.efi /Y
bcdedit /create {0cb3b571-2f2e-4343-a879-d86a476d7215} /d "DebugTool" /application osloader
bcdedit /set {0cb3b571-2f2e-4343-a879-d86a476d7215} path "\EFI\Microsoft\Boot\SecConfig.efi"
bcdedit /set {bootmgr} bootsequence {0cb3b571-2f2e-4343-a879-d86a476d7215}
bcdedit /set {0cb3b571-2f2e-4343-a879-d86a476d7215} loadoptions DISABLE-LSA-ISO
bcdedit /set {0cb3b571-2f2e-4343-a879-d86a476d7215} device partition=X:
mountvol X: /d

Redémarrez le PC.
Acceptez l’invite de désactivation de Credential Guard.
Vous pouvez également désactiver les fonctionnalités de sécurité basée sur la virtualisation pour désactiver Credential Guard.

Remarque

Le PC doit disposer d’un accès unique à un contrôleur de domaine pour déchiffrer du contenu, les fichiers chiffrés avec EFS par exemple.

Si vous voulez désactiver Credential Guard et la sécurité basée sur la virtualisation, exécutez la commande BCDEdit suivante après avoir désactivé tous les paramètres de stratégie de groupe et de Registre de sécurité basée sur la virtualisation :

bcdedit /set {0cb3b571-2f2e-4343-a879-d86a476d7215} loadoptions DISABLE-LSA-ISO,DISABLE-VBS

Pour plus d’informations sur la sécurité basée sur la virtualisation et sur Device Guard, voir Guide de déploiement de Microsoft Device Guard.

Vérifier que Credential Guard est en cours d’exécution

Vous pouvez utiliser les informations système pour vérifier si Credential Guard est en cours d’exécution sur un PC.

Cliquez sur Démarrer, tapez msinfo32.exe, puis cliquez sur Informations système.
Cliquez sur Résumé système.
Vérifiez que Credential Guard apparaît en regard de Services de sécurité Device Guard en cours d’exécution.

Voici un exemple :

Considérations lors de l’utilisation de Credential Guard

Si Credential Guard est activé sur un appareil une fois qu’il est associé à un domaine, les secrets utilisateur et appareil peuvent déjà être compromis. Nous recommandons d’activer Credential Guard avant l’association du PC à un domaine.
Vous devez passer régulièrement en revue les PC sur lesquels Credential Guard est activé. Vous pouvez le faire avec des stratégies d’audit de sécurité ou des requêtes WMI. Voici une liste des ID d’événements WinInit à rechercher :
- ID d’événement 13 Credential Guard (LsaIso.exe) est démarré et protège les informations d’identification de l’autorité de sécurité locale.
- ID d’événement 14 Configuration de Credential Guard (LsaIso.exe) : 0x1, 0
  - La première variable, 0x1, indique que Credential Guard est configuré pour l’exécution. 0x0 indique qu’il n’est pas configuré pour l’exécution.
  - La seconde variable, 0, indique qu’il est configuré pour une exécution en mode protection. 1 indique qu’il est configuré pour une exécution en mode test. Cette variable doit toujours être 0.
- ID d’événement 15 Credential Guard (LsaIso.exe) est configuré, mais le noyau sécurisé n’est pas en cours d’exécution ; poursuite sans Credential Guard.
- ID d’événement 16 Le lancement de Credential Guard (LsaIso.exe) a échoué : [code d’erreur]
- ID d’événement 17 Erreur de lecture de la configuration UEFI de Credential Guard (LsaIso.exe) : [code d’erreur]
Vous pouvez également vérifier que le module TPM est utilisé pour la protection de clé en vérifiant l’événement suivant dans la source de l’événement Microsoft -> Windows -> Kernel-Boot. Si vous utilisez un module TPM, la valeur de masque PCR de ce module est différente de 0.
- ID d’événement 51 Mise en service de la clé de chiffrement principale VSM. Utilisation de l’état de la copie mise en cache : 0x0. Descellement de l’état de la copie mise en cache : 0x1. Nouvel état de la génération de clé : 0x1. Scellement de l’état : 0x1. Masque PCR du module TPM : 0x0.
Les mots de passe sont encore faibles. Nous recommandons donc à votre organisation de déployer Credential Guard et de passer des mots de passe à d’autres méthodes d’authentification comme les cartes à puce physiques ou virtuelles, Microsoft Passport ou Microsoft Passport for Work.
Certains fournisseurs SSP (Security Support Provider) tiers (points d’accès compris) peuvent ne pas être compatibles avec Credential Guard. Credential Guard ne permet pas aux fournisseurs SSP tiers de demander des hachages de mot de passe à l’autorité de sécurité locale. Toutefois, les fournisseurs SSP et les points d’accès reçoivent toujours des notifications du mot de passe lorsqu’un utilisateur se connecte et/ou modifie son mot de passe. Aucune utilisation d’API non documentées dans des fournisseurs SSP et des points d’accès personnalisés n’est prise en charge. Nous recommandons que les implémentations personnalisées des fournisseurs SSP/points d’accès soient testées par rapport à Credential Guard afin de s’assurer que les fournisseurs SSP/points d’accès ne dépendent d’aucun comportement non documenté ou non pris en charge. Par exemple, l’utilisation de l’API KerbQuerySupplementalCredentialsMessage n’est pas prise en charge. Vous ne devez pas remplacer les fournisseurs SSP NTLM ou Kerberos par des fournisseurs SSP et des points d’accès personnalisés. Pour plus d’informations, voir l’article Restrictions relatives à l’inscription et à l’installation d’un package de sécurité sur MSDN.
La profondeur et l’étendue des protections fournies par Credential Guard évoluant sans cesse, les versions ultérieures de Windows 10 avec Credential Guard peuvent affecter des scénarios qui fonctionnaient précédemment. Par exemple, Credential Guard peut bloquer l’utilisation d’un type d’informations d’identification particulier ou un composant spécifique pour empêcher des programmes malveillants d’exploiter des vulnérabilités. Par conséquent, nous recommandons que les scénarios nécessaires aux opérations d’une organisation soient testés avant de mettre à niveau un appareil sur lequel Credential Guard est exécuté.
Si vous utilisez des points de terminaison Wi-Fi et VPN basés sur MS-CHAPv2, ils sont soumis à des attaques similaires à NTLMv1. Nous recommandons aux organisations d’utiliser une authentification par certificat pour les connexions Wi-Fi et VPN.
Depuis Windows 10, version 1511, les informations d’identification de domaine stockées avec le gestionnaire d’informations d’identification sont protégées par Credential Guard. Le gestionnaire d’informations d’identification vous permet de stocker des informations d’identification, telles que les noms d’utilisateur et les mots de passe que vous utilisez pour vous connecter à des sites web ou à d’autres ordinateurs d’un réseau. Les considérations suivantes s’appliquent aux protections Credential Guard pour le gestionnaire d’informations d’identification :
- Les informations d’identification enregistrées par les services Bureau à distance ne peuvent pas être utilisées pour se connecter à distance à un autre ordinateur sans fournir le mot de passe.
- Les applications qui extraient les informations d’identification de domaine dérivées de Credential Manager ne seront plus en mesure d’utiliser ces informations.
- Vous ne pouvez pas restaurer les informations d’identification à l’aide du panneau Gestionnaire d’informations d’identification si elles ont été sauvegardées à partir d’un PC sur lequel Credential Guard est activé. Si vous avez besoin sauvegarder vos informations d’identification, vous devez le faire avant d’activer Credential Guard. Sinon, vous ne serez pas en mesure de restaurer ces informations d’identification.

Scénarios non protégés par Credential Guard

Certaines méthodes de stockage des informations d’identification ne sont pas protégées par Credential Guard, notamment :

Le logiciel gérant les informations d’identification en dehors de la protection de fonctionnalité.
Les comptes locaux et les comptes Microsoft.
Un serveur Windows Server 2016 Technical Preview exécutant certains rôles serveur, un contrôleur de domaine ou une passerelle des services Bureau à distance par exemple. Si vous utilisez un serveur Windows Server 2016 Technical Preview en tant que PC client, il dispose de la même protection que s’il exécutait Windows 10 Enterprise.
Les enregistreurs de frappe
Les attaques physiques
N’empêche pas une personne malveillante disposant d’un logiciel malveillant sur le PC d’utiliser les privilèges associés à n’importe quelle information d’identification. Nous vous recommandons d’utiliser des PC dédiés pour les comptes à valeur élevée, comme les professionnels de l’informatique et les utilisateurs ayant accès aux actifs à valeur élevée de votre organisation.

Préventions supplémentaires

Credential Guard peut fournir des préventions contre les attaques sur les informations d’identification dérivées et empêcher l’utilisation des informations d’identification volées. Toutefois, les PC sont toujours vulnérables à certaines attaques, même si les informations d’identification dérivées sont protégées par Credential Guard. Ces attaques peuvent inclure l’utilisation frauduleuse des privilèges et l’utilisation des informations d’identification dérivées directement à partir d’un appareil compromis, la réutilisation des informations d’identification précédemment volées avant la mise en place de Device Guard, et l’abus des outils de gestion et des configurations d’applications faibles. Des préventions supplémentaires ont donc dû être déployées également pour rendre l’environnement de domaine plus robuste.

Les attaques par vol des informations d’identification permettent à la personne malveillante de voler des secrets sur un appareil et les utiliser sur un autre appareil. En déployant des stratégies d’authentification avec une authentification composée dans Windows Server 2012 R2 ou domaines ultérieurs, les utilisateurs peuvent être restreints à une connexion à partir d’appareils associés à un domaine spécifique uniquement. Toutefois, étant donné que les appareils utilisent également des secrets partagés pour l’authentification, les personnes malveillantes peuvent voler ces secrets également. En déployant des certificats d’appareil avec Credential Guard, les stratégies d’authentification peuvent exiger que l’appareil s'authentifie avec sa clé privée. Cela permet d’empêcher l’utilisation de secrets partagés sur des appareils volés avec des mots de passe utilisateur ou des clés secrètes Kerberos volés pour se faire passer pour l’utilisateur lors de la connexion.

L’authentification par certificat d’appareil inclut les exigences suivantes :

Les domaines d’appareil sont Windows Server 2012 ou version supérieure et tous les contrôleurs de domaine incluent des certificats conformes à une validation du contrôleur de domaine Kerberos (KDC) stricte (présence de l’EKU KDC et le nom de domaine DNS correspond au champ DNSName de l’extension SubjectAltName (SAN)).
Les appareils Windows 10 incluent l’autorité de certification générant les certificats de contrôleur de domaine dans le magasin d’entreprise.
Un processus est établi pour garantir l’identité et la fiabilité de l’appareil, de la même manière que vous établiriez l’identité et la fiabilité d’un utilisateur avant d’émettre une carte à puce.

Paramètres de stratégie de groupe supplémentaires

Vous pouvez activer des paramètres de stratégie de groupe offrant une meilleure protection contre les attaques par informations d’identification :

Sur les contrôleurs de domaine, configurez la prise en charge du contrôleur de domaine Kerberos (KDC) pour les réclamations, l’authentification composée et le système de protection Kerberos à l’aide de la stratégie de groupe. Définissez le paramètre de stratégie de groupe Prise en charge du contrôleur de domaine Kerberos (KDC) pour les réclamations, l’authentification composée et la protection Kerberos sur Pris en charge ou Toujours fournir des réclamations.
Sur les appareils exécutant Windows 10, vous pouvez également l’activer à l’aide d’une stratégie de groupe. Pour ce faire, activez les paramètres de stratégie de groupe Prise en charge du client Kerberos pour les réclamations, l’authentification composée et la protection Kerberos et Toujours envoyer l’authentification composée en premier au système sous Configuration ordinateur -> Modèles d'administration -> Système -> Kerberos.

Authentification composée

L’authentification composée ajoute l’identité de l’appareil à l’utilisateur lors de l’authentification au domaine et aux ressources. Sans l’authentification composée, seuls les secrets de l’utilisateur sont validés. Avec l’authentification composée, le client Kerberos doit disposer des secrets de l’utilisateur et de l’appareil.

L’activation de l’authentification composée active également la protection Kerberos, ce qui offre deux avantages supplémentaires :

L’authentification utilisateur sur des appareils associés à un domaine sera protégée. Cela signifie que l’authentification initiale Kerberos sera chiffrée dans les captures réseau. Sans la clé d’appareil appropriée, les AS-REQ Kerberos sont protégés contre les attaques par dictionnaire hors connexion.
Les erreurs du contrôleur de domaine Kerberos (KDC) sont signées, offrant ainsi une protection contre les attaques par usurpation d’erreur.

Déploiement de certificats d’ordinateurs

Si les contrôleurs de domaine de votre organisation exécutent Windows Server 2016 Technical Preview, les appareils exécutant Windows 10 inscrivent automatiquement un certificat d’ordinateur lorsque Credential Guard est activé et que le PC est associé au domaine.

Si les contrôleurs de domaine exécutent Windows Server 2012 R2, les certificats d’ordinateur doivent être mise en service manuellement sur chaque appareil. Vous pouvez le faire en créant un modèle de certificat sur le contrôleur de domaine ou l’autorité de certification et en déployant les certificats d’ordinateur sur chaque appareil.

Les mêmes procédures de sécurité utilisées pour l’émission de cartes à puce destinées aux utilisateurs doivent être appliquées pour les certificats d’ordinateur.

Dans la console du Gestionnaire de certificats, cliquez avec le bouton droit sur Modèles de certificats, puis cliquez sur Gérer.
Cliquez avec le bouton droit sur Authentification de station de travail, puis cliquez sur Dupliquer le modèle.
Cliquez avec le bouton droit sur le nouveau modèle, puis cliquez sur Propriétés.
Dans l’onglet Extensions, cliquez sur Stratégies d’application, puis cliquez sur Modifier.
Cliquez sur Authentification client, puis cliquez sur Supprimer.
Ajoutez l’EKU ID-PKInit-KPClientAuth. Cliquez sur Ajouter, cliquez sur Nouveau, puis spécifiez les valeurs suivantes :
- Nom : Kerberos Client Auth
- Identificateur d’objet : 1.3.6.1.5.2.3.4
Dans l’onglet Extensions, cliquez sur Stratégies d’émission, puis cliquez sur Modifier.
Sous Stratégies d’émission, cliquez sur Garantie élevée.
Dans l’onglet Nom de l’objet, décochez la case Nom DNS, puis cochez la case Nom principal de l’utilisateur (UPN).

Sur les appareils exécutant Credential Guard, inscrivez les appareils à l'aide du certificat d’authentification d’ordinateur en exécutant la commande suivante :

CertReq -EnrollCredGuardCert MachineAuthentication

Remarque

Vous devez redémarrer l’appareil après l’inscription du certificat d’authentification d’ordinateur.

Lier les stratégies d’émission à un groupe

En utilisant une stratégie d’authentification, vous pouvez faire en sorte que les utilisateurs s’inscrivent uniquement aux appareils exécutant Credential Guard. Avant de déployer la stratégie d’authentification, vous devez tout d’abord exécuter deux scripts qui configurent votre environnement.

get-IssuancePolicy.ps1 montre toutes les stratégies d’émission disponibles sur l’autorité de certification.

Dans une invite de commandes Windows PowerShell, exécutez la commande suivante :
```
.\get-IssuancePolicy.ps1 –LinkedToGroup:All
```
set-IssuancePolicyToGroupLink.ps1 crée un groupe de sécurité universel, une unité d’organisation et lie la stratégie d’émission à ce groupe de sécurité universel.

Dans une invite de commandes Windows PowerShell, exécutez la commande suivante :
```
.\set-IssuancePolicyToGroupLink.ps1 –IssuancePolicyName:”<name of issuance policy>” –groupOU:”<Name of OU to create>” –groupName:”<name of Universal security group to create>”
```

Déployer la stratégie d’authentification

Avant de configurer la stratégie d’authentification, vous devez consigner toute tentative d’application d’une stratégie d’authentification au contrôleur de domaine Kerberos ayant échoué. Pour ce faire, dans l’Observateur d’événements, accédez à Journaux d’applications et de services\Microsoft\Windows\Authentification, cliquez avec le bouton droit sur AuthenticationPolicyFailures-DomainController, puis cliquez sur Activer le journal.

Vous pouvez maintenir définir une stratégie d’authentification pour utiliser Credential Guard.

Mt483740.wedge(fr-fr,VS.85).gif Pour ajouter une stratégie d’authentification pour Credential Guard

Assurez-vous que vos contrôleurs de domaine sont en cours d’exécution au moins au niveau fonctionnel du domaine Windows Server 2012 R2.
Créez un groupe de sécurité qui sera utilisé pour identifier les PC auxquels cette stratégie d’authentification sera appliquée.
Ajoutez le compte d’ordinateur à ce groupe de sécurité.
Ouvrez le Centre d’administration Active Directory.
Cliquez sur Authentification, cliquez sur Nouveau, puis cliquez sur Stratégie d’authentification.
Dans la zone Nom complet, entrez un nom pour cette stratégie d’authentification.
Sous le titre Comptes, cliquez sur Ajouter.
Dans la boîte de dialogue Sélectionner les comptes d’utilisateur, d’ordinateur ou de service, tapez le nom du compte d’utilisateur, puis cliquez sur OK.
Sous le titre Utilisateur, cliquez sur le bouton Modifier correspondant au compte d’utilisateur.
Cliquez sur Ajouter une condition.
Dans la zone Modifier les conditions de contrôle d’accès, vérifiez l’affichage Utilisateur > Groupe > Membre de chaque > Valeur, puis cliquez sur Ajouter des éléments.
Dans la boîte de dialogue Sélectionner des comptes d’utilisateur, d’ordinateur ou de service, tapez le nom du groupe de sécurité que vous avez créé avec le script IssuancePolicyToGroupLink, puis cliquez sur OK.
Cliquez sur OK pour fermer la zone Modifier les conditions de contrôle d’accès.
Cliquez sur OK pour créer la stratégie d’authentification.
Fermez le Centre d’administration Active Directory.

Remarque

Lorsque les stratégies d’authentification en mode d’application sont déployées avec Credential Guard, les utilisateurs ne pourront pas ouvrir de session à l’aide d’appareils sur lesquels le certificat d’authentification d’ordinateur n’est pas mis en service. Cela s’applique aux scénarios d’ouverture de session locale et distante.

Annexe : Scripts

Voici une liste des scripts mentionnés dans cette rubrique.

Obtenir les stratégies d’émission disponibles sur l’autorité de certification

Enregistrez ce fichier de script sous get-IssuancePolicy.ps1.

#######################################
##     Parameters to be defined      ##
##     by the user                   ##
#######################################

Param (
$Identity,
$LinkedToGroup
)

#######################################
##     Strings definitions           ##
#######################################
Data getIP_strings {
# culture=\"en-US\"
ConvertFrom-StringData -stringdata @'
help1 = This command can be used to retrieve all available Issuance Policies in a forest. The forest of the currently logged on user is targetted.
help2 = Usage:
help3 = The following parameter is mandatory:
help4 = -LinkedToGroup:<yes|no|all>
help5 = "yes" will return only Issuance Policies that are linked to groups. Checks that the linked Issuance Policies are linked to valid groups.
help6 = "no" will return only Issuance Policies that are not currently linked to any group. 
help7 = "all" will return all Issuance Policies defined in the forest. Checks that the linked Issuance policies are linked to valid groups.
help8 = The following parameter is optional:
help9 = -Identity:<Name, Distinguished Name or Display Name of the Issuance Policy that you want to retrieve>. If you specify an identity, the option specified in the "-LinkedToGroup" parameter is ignored.
help10 = Output: This script returns the Issuance Policy objects meeting the criteria defined by the above parameters.
help11 = Examples:
errorIPNotFound = Error: no Issuance Policy could be found with Identity "{0}"
ErrorNotSecurity = Error: Issuance Policy "{0}" is linked to group "{1}" which is not of type "Security".
ErrorNotUniversal = Error: Issuance Policy "{0}" is linked to group "{1}" whose scope is not "Universal".
ErrorHasMembers = Error: Issuance Policy "{0}" is linked to group "{1}" which has a non-empty membership. The group has the following members:
LinkedIPs = The following Issuance Policies are linked to groups:
displayName = displayName : {0}
Name = Name : {0}
dn = distinguishedName : {0}
        InfoName = Linked Group Name: {0} 
        InfoDN = Linked Group DN: {0}   
NonLinkedIPs = The following Issuance Policies are NOT linked to groups:
'@
}

##Import-LocalizedData getIP_strings


import-module ActiveDirectory


#######################################
##           Help                    ##
#######################################

function Display-Help {

    ""
    $getIP_strings.help1
    ""
$getIP_strings.help2
""
$getIP_strings.help3
"     " + $getIP_strings.help4
"             " + $getIP_strings.help5
    "             " + $getIP_strings.help6
    "             " + $getIP_strings.help7
""
$getIP_strings.help8
    "     " + $getIP_strings.help9
    ""
    $getIP_strings.help10
""
""    
$getIP_strings.help11
    "     " + '$' + "myIPs = .\get-IssuancePolicy.ps1 -LinkedToGroup:All"
    "     " + '$' + "myLinkedIPs = .\get-IssuancePolicy.ps1 -LinkedToGroup:yes"
    "     " + '$' + "myIP = .\get-IssuancePolicy.ps1 -Identity:""Medium Assurance"""
""
}


$root = get-adrootdse
$domain = get-addomain -current loggedonuser
$configNCDN = [String]$root.configurationNamingContext


if ( !($Identity) -and !($LinkedToGroup) ) {
display-Help
break
}

if ($Identity) {
    $OIDs = get-adobject -Filter {(objectclass -eq "msPKI-Enterprise-Oid") -and ((name -eq $Identity) -or (displayname -eq $Identity) -or (distinguishedName -like $Identity)) } -searchBase $configNCDN -properties *

    if ($OIDs -eq $null) {
$errormsg = $getIP_strings.ErrorIPNotFound -f $Identity
write-host $errormsg -ForegroundColor Red
    }
    
    foreach ($OID in $OIDs) {
    
        if ($OID."msDS-OIDToGroupLink") {
            # In case the Issuance Policy is linked to a group, it is good to check whether there is any problem with the mapping.
            $groupDN = $OID."msDS-OIDToGroupLink"
            $group = get-adgroup -Identity $groupDN
    $groupName = $group.Name
            
            # Analyze the group
            if ($group.groupCategory -ne "Security") {
$errormsg = $getIP_strings.ErrorNotSecurity -f $Identity, $groupName
                write-host $errormsg -ForegroundColor Red
            }
            if ($group.groupScope -ne "Universal") {
                $errormsg = $getIP_strings.ErrorNotUniversal -f $Identity, $groupName
write-host $errormsg -ForegroundColor Red
            }
            $members = Get-ADGroupMember -Identity $group
            if ($members) {
                $errormsg = $getIP_strings.ErrorHasMembers -f $Identity, $groupName
write-host $errormsg -ForegroundColor Red
                foreach ($member in $members) {
                    write-host "          "  $member -ForeGroundColor Red
                }
            }
        }
        
    }
    return $OIDs
    break
}

if (($LinkedToGroup -eq "yes") -or ($LinkedToGroup -eq "all")) {
    $LDAPFilter = "(&(objectClass=msPKI-Enterprise-Oid)(msDS-OIDToGroupLink=*)(flags=2))"
    $LinkedOIDs = get-adobject -searchBase $configNCDN -LDAPFilter $LDAPFilter -properties *

    write-host ""    
    write-host "*****************************************************"
    write-host $getIP_strings.LinkedIPs
    write-host "*****************************************************"
    write-host ""
    if ($LinkedOIDs -ne $null){
      foreach ($OID in $LinkedOIDs) {
  
          # Display basic information about the Issuance Policies
          ""
  $getIP_strings.displayName -f $OID.displayName
  $getIP_strings.Name -f $OID.Name
  $getIP_strings.dn -f $OID.distinguishedName
       
          
          # Get the linked group.
          $groupDN = $OID."msDS-OIDToGroupLink"
          $group = get-adgroup -Identity $groupDN
          $getIP_strings.InfoName -f $group.Name
          $getIP_strings.InfoDN -f $groupDN
          
          # Analyze the group
          $OIDName = $OID.displayName
    $groupName = $group.Name
          if ($group.groupCategory -ne "Security") {
          $errormsg = $getIP_strings.ErrorNotSecurity -f $OIDName, $groupName
          write-host $errormsg -ForegroundColor Red
          }
          if ($group.groupScope -ne "Universal") {
          $errormsg = $getIP_strings.ErrorNotUniversal -f $OIDName, $groupName
          write-host $errormsg -ForegroundColor Red
          }
          $members = Get-ADGroupMember -Identity $group
          if ($members) {
          $errormsg = $getIP_strings.ErrorHasMembers -f $OIDName, $groupName
          write-host $errormsg -ForegroundColor Red
              foreach ($member in $members) {
                  write-host "          "  $member -ForeGroundColor Red
              }
          }
          write-host ""
      }
    }else{
write-host "There are no issuance policies that are mapped to a group"
    }
    if ($LinkedToGroup -eq "yes") {
        return $LinkedOIDs
        break
    }
}    

if (($LinkedToGroup -eq "no") -or ($LinkedToGroup -eq "all")) {  
    $LDAPFilter = "(&(objectClass=msPKI-Enterprise-Oid)(!(msDS-OIDToGroupLink=*))(flags=2))"
    $NonLinkedOIDs = get-adobject -searchBase $configNCDN -LDAPFilter $LDAPFilter -properties *

    write-host ""    
    write-host "*********************************************************"
    write-host $getIP_strings.NonLinkedIPs
    write-host "*********************************************************"
    write-host ""
    if ($NonLinkedOIDs -ne $null) {
      foreach ($OID in $NonLinkedOIDs) {

# Display basic information about the Issuance Policies
write-host ""
$getIP_strings.displayName -f $OID.displayName
$getIP_strings.Name -f $OID.Name
$getIP_strings.dn -f $OID.distinguishedName
write-host ""
      }
    }else{
write-host "There are no issuance policies which are not mapped to groups"
    }
    if ($LinkedToGroup -eq "no") {
        return $NonLinkedOIDs
        break
    }
}

Remarque

Si vous ne parvenez pas à exécuter ce script, essayez de remplacer l’apostrophe après le paramètre ConvertFrom-StringData.

Lier une stratégie d’émission à un groupe

Enregistrez le fichier de script sous IssuancePolicyToGroupLink.ps1.

#######################################
##     Parameters to be defined      ##
##     by the user                   ##
#######################################

Param (
$IssuancePolicyName,
$groupOU,
$groupName
)

#######################################
##     Strings definitions           ##
#######################################

Data ErrorMsg {
# culture=\"en-US\"
ConvertFrom-StringData -stringdata @'
help1 = This command can be used to set the link between a certificate issuance policy and a universal security group.
help2 = Usage:
help3 = The following parameters are required:
help4 = -IssuancePolicyName:<name or display name of the issuance policy that you want to link to a group>
help5 = -groupName:<name of the group you want to link the issuance policy to>. If no name is specified, any existing link to a group is removed from the Issuance Policy.
help6 = The following parameter is optional:
help7 = -groupOU:<Name of the Organizational Unit dedicated to the groups which are linked to issuance policies>. If this parameter is not specified, the group is looked for or created in the Users container.
help8 = Examples:
help9 = This command will link the issuance policy whose display name is "High Assurance" to the group "HighAssuranceGroup" in the Organizational Unit "OU_FOR_IPol_linked_groups". If the group or the Organizational Unit do not exist, you will be prompted to create them.
help10 = This command will unlink the issuance policy whose name is "402.164959C40F4A5C12C6302E31D5476062" from any group.
MultipleIPs = Error: Multiple Issuance Policies with name or display name "{0}" were found in the subtree of "{1}"
NoIP = Error: no issuance policy with name or display name "{0}" could be found in the subtree of "{1}".
IPFound = An Issuance Policy with name or display name "{0}" was successfully found: {1}
MultipleOUs = Error: more than 1 Organizational Unit with name "{0}" could be found in the subtree of "{1}".
confirmOUcreation = Warning: The Organizational Unit that you specified does not exist. Do you want to create it?
OUCreationSuccess = Organizational Unit "{0}" successfully created.
OUcreationError = Error: Organizational Unit "{0}" could not be created.
OUFoundSuccess = Organizational Unit "{0}" was successfully found.
multipleGroups = Error: More than one group with name "{0}" was found in Organizational Unit "{1}".  
confirmGroupCreation = Warning: The group that you specified does not exist. Do you want to create it?
groupCreationSuccess = Univeral Security group "{0}" successfully created.
groupCreationError = Error: Univeral Security group "{0}" could not be created.
GroupFound = Group "{0}" was successfully found.
confirmLinkDeletion = Warning: The Issuance Policy "{0}" is currently linked to group "{1}". Do you really want to remove the link?
UnlinkSuccess = Certificate issuance policy successfully unlinked from any group.
UnlinkError = Removing the link failed.
UnlinkExit = Exiting without removing the link from the issuance policy to the group.
IPNotLinked = The Certificate issuance policy is not currently linked to any group. If you want to link it to a group, you should specify the -groupName option when starting this script.
ErrorNotSecurity = Error: You cannot link issuance Policy "{0}" to group "{1}" because this group is not of type "Security".
ErrorNotUniversal = Error: You cannot link issuance Policy "{0}" to group "{1}" because the scope of this group is not "Universal".
ErrorHasMembers = Error: You cannot link issuance Policy "{0}" to group "{1}" because it has a non-empty membership. The group has the following members:
ConfirmLinkReplacement = Warning: The Issuance Policy "{0}" is currently linked to group "{1}". Do you really want to update the link to point to group "{2}"?
LinkSuccess = The certificate issuance policy was successfully linked to the specified group.
LinkError = The certificate issuance policy could not be linked to the specified group.
ExitNoLinkReplacement = Exiting without setting the new link.
'@
}

# import-localizeddata ErrorMsg

function Display-Help {
""
write-host $ErrorMsg.help1
""
write-host $ErrorMsg.help2
""
write-host $ErrorMsg.help3
write-host "`t" $ErrorMsg.help4
write-host "`t" $ErrorMsg.help5
""
write-host $ErrorMsg.help6
write-host "`t" $ErrorMsg.help7
""
""
write-host $ErrorMsg.help8
""
write-host $ErrorMsg.help9
".\Set-IssuancePolicyToGroupMapping.ps1 -IssuancePolicyName ""High Assurance"" -groupOU ""OU_FOR_IPol_linked_groups"" -groupName ""HighAssuranceGroup"" "
""
write-host $ErrorMsg.help10
'.\Set-IssuancePolicyToGroupMapping.ps1 -IssuancePolicyName "402.164959C40F4A5C12C6302E31D5476062" -groupName $null '
""
}



# Assumption:  The group to which the Issuance Policy is going 
#              to be linked is (or is going to be created) in 
#              the domain the user running this script is a member of.
import-module ActiveDirectory
$root = get-adrootdse
$domain = get-addomain -current loggedonuser


if ( !($IssuancePolicyName) ) {
display-Help
break
}

#######################################
##     Find the OID object           ##
##     (aka Issuance Policy)         ##
#######################################

$searchBase = [String]$root.configurationnamingcontext
$OID = get-adobject -searchBase $searchBase -Filter { ((displayname -eq $IssuancePolicyName) -or (name -eq $IssuancePolicyName)) -and (objectClass -eq "msPKI-Enterprise-Oid")} -properties *

if ($OID -eq $null) {
$tmp = $ErrorMsg.NoIP -f $IssuancePolicyName, $searchBase  
write-host $tmp -ForeGroundColor Red
break;
}
elseif ($OID.GetType().IsArray) {
$tmp = $ErrorMsg.MultipleIPs -f $IssuancePolicyName, $searchBase  
write-host $tmp -ForeGroundColor Red
break;
}
else {
$tmp = $ErrorMsg.IPFound -f $IssuancePolicyName, $OID.distinguishedName
write-host $tmp -ForeGroundColor Green
}



#######################################
##  Find the container of the group  ##
#######################################

if ($groupOU -eq $null) {
# default to the Users container
$groupContainer = $domain.UsersContainer
} 
else {
$searchBase = [string]$domain.DistinguishedName
$groupContainer = get-adobject -searchBase $searchBase -Filter { (Name -eq $groupOU) -and (objectClass -eq "organizationalUnit")}
if ($groupContainer.count -gt 1) {
$tmp = $ErrorMsg.MultipleOUs -f $groupOU, $searchBase
write-host $tmp -ForegroundColor Red
break;
}
elseif ($groupContainer -eq $null) {
$tmp = $ErrorMsg.confirmOUcreation
write-host $tmp " ( (y)es / (n)o )" -ForegroundColor Yellow -nonewline
$userChoice = read-host
if ( ($userChoice -eq "y") -or ($userChoice -eq "yes") ) {
new-adobject -Name $groupOU -displayName $groupOU -Type "organizationalUnit" -ProtectedFromAccidentalDeletion $true -path $domain.distinguishedName
if ($?){
$tmp = $ErrorMsg.OUCreationSuccess -f $groupOU
write-host $tmp -ForegroundColor Green
}
else{
$tmp = $ErrorMsg.OUCreationError -f $groupOU
write-host $tmp -ForeGroundColor Red 
break;
}
$groupContainer = get-adobject -searchBase $searchBase -Filter { (Name -eq $groupOU) -and (objectClass -eq "organizationalUnit")}
}
else {
break;
}
}
else {
$tmp = $ErrorMsg.OUFoundSuccess -f $groupContainer.name
write-host $tmp -ForegroundColor Green
}
}

#######################################
##  Find the group               ##
#######################################

if (($groupName -ne $null) -and ($groupName -ne "")){
##$searchBase = [String]$groupContainer.DistinguishedName
$searchBase = $groupContainer
$group = get-adgroup -Filter { (Name -eq $groupName) -and (objectClass -eq "group") } -searchBase $searchBase
if ($group -ne $null -and $group.gettype().isarray) {
$tmp = $ErrorMsg.multipleGroups -f $groupName, $searchBase
write-host $tmp -ForeGroundColor Red
break;
}
elseif ($group -eq $null) {
$tmp = $ErrorMsg.confirmGroupCreation
write-host $tmp " ( (y)es / (n)o )" -ForegroundColor Yellow -nonewline
$userChoice = read-host
if ( ($userChoice -eq "y") -or ($userChoice -eq "yes") ) {
new-adgroup -samAccountName $groupName -path $groupContainer.distinguishedName -GroupScope "Universal" -GroupCategory "Security"
if ($?){
$tmp = $ErrorMsg.GroupCreationSuccess -f $groupName
write-host $tmp -ForegroundColor Green
}else{
$tmp = $ErrorMsg.groupCreationError -f $groupName
write-host $tmp -ForeGroundColor Red 
break
}
$group = get-adgroup -Filter { (Name -eq $groupName) -and (objectClass -eq "group") } -searchBase $searchBase
}
else {
break;
}
}
else {
$tmp = $ErrorMsg.GroupFound -f $group.Name
write-host $tmp -ForegroundColor Green
}
} 
else {
## If the group is not specified, we should remove the link if any exists
if ($OID."msDS-OIDToGroupLink" -ne $null) {
$tmp = $ErrorMsg.confirmLinkDeletion -f $IssuancePolicyName, $OID."msDS-OIDToGroupLink"
write-host $tmp " ( (y)es / (n)o )" -ForegroundColor Yellow -nonewline
$userChoice = read-host
if ( ($userChoice -eq "y") -or ($userChoice -eq "yes") ) {
set-adobject -Identity $OID -Clear "msDS-OIDToGroupLink"
if ($?) {
$tmp = $ErrorMsg.UnlinkSuccess
write-host $tmp -ForeGroundColor Green
}else{
$tmp = $ErrorMsg.UnlinkError
write-host $tmp -ForeGroundColor Red
}
} 
else { 
$tmp = $ErrorMsg.UnlinkExit
write-host $tmp
break 
}
}
else {
$tmp = $ErrorMsg.IPNotLinked
write-host $tmp -ForeGroundColor Yellow
}
break;
}


#######################################
##  Verify that the group is         ##
##  Universal, Security, and         ## 
##  has no members                   ##
#######################################

if ($group.GroupScope -ne "Universal") {
$tmp = $ErrorMsg.ErrorNotUniversal -f $IssuancePolicyName, $groupName
write-host $tmp -ForeGroundColor Red
break;
}
if ($group.GroupCategory -ne "Security") {
$tmp = $ErrorMsg.ErrorNotSecurity -f $IssuancePolicyName, $groupName
write-host $tmp -ForeGroundColor Red
break;
}
$members = Get-ADGroupMember -Identity $group
if ($members -ne $null) {
$tmp = $ErrorMsg.ErrorHasMembers -f $IssuancePolicyName, $groupName
write-host $tmp -ForeGroundColor Red
foreach ($member in $members) {write-host "   $member.name" -ForeGroundColor Red}
break;
}


#######################################
##  We have verified everything. We  ##
##  can create the link from the     ## 
##  Issuance Policy to the group.    ##
#######################################

if ($OID."msDS-OIDToGroupLink" -ne $null) {
$tmp = $ErrorMsg.ConfirmLinkReplacement -f $IssuancePolicyName, $OID."msDS-OIDToGroupLink", $group.distinguishedName
write-host $tmp  "( (y)es / (n)o )" -ForegroundColor Yellow -nonewline
$userChoice = read-host
if ( ($userChoice -eq "y") -or ($userChoice -eq "yes") ) {
$tmp = @{'msDS-OIDToGroupLink'= $group.DistinguishedName}
set-adobject -Identity $OID -Replace $tmp
if ($?) {
$tmp = $Errormsg.LinkSuccess
write-host $tmp -Foreground Green
}else{
$tmp = $ErrorMsg.LinkError
write-host $tmp -Foreground Red
}
} else { 
$tmp = $Errormsg.ExitNoLinkReplacement
write-host $tmp
break 
}
}
else {
$tmp = @{'msDS-OIDToGroupLink'= $group.DistinguishedName}
set-adobject -Identity $OID -Add $tmp
if ($?) {
$tmp = $Errormsg.LinkSuccess
write-host $tmp -Foreground Green
}else{
$tmp = $ErrorMsg.LinkError
write-host $tmp -Foreground Red
}
}

Remarque

Si vous ne parvenez pas à exécuter ce script, essayez de remplacer l’apostrophe après le paramètre ConvertFrom-StringData.