MS14-025: Sicherheitsrisiko in Gruppenrichtlinieneinstellungen könnte Rechteerweiterungen ermöglichen: 13. Mai 2014

Wichtige Änderungen

Aktion: Erstellen oder Ersetzen

• Die Felder Benutzername, Kennwort und Kennwort bestätigen sind deaktiviert.

• Das Warndialogfeld wird angezeigt, wenn der Administrator eine vorhandene Einstellung, die ein Kennwort enthält, öffnet oder Änderungen daran vornimmt und zu speichern versucht.

Aktion: Aktualisieren

• Die Felder Kennwort und Kennwort bestätigen sind deaktiviert.

• Das Warndialogfeld wird angezeigt, wenn der Administrator eine vorhandene Einstellung, die ein Kennwort enthält, öffnet oder Änderungen daran vornimmt und zu speichern versucht.

Aktion: Löschen

• Keine Änderung im Verhalten

Problemumgehungen

Für alle, die früher die Kennwörter für lokale Administratoren über Gruppenrichtlinieneinstellungen festgelegt haben, wird das folgende Skript als Alternative zu CPassword bereitgestellt. Kopieren Sie den Inhalt, und speichern Sie ihn in einer neuen Windows PowerShell-Datei. Führen Sie das Skript dann wie im Skript im Abschnitt .EXAMPLE angegeben aus.

Die Verwendung der hier aufgeführten Informationen, Makro- oder Programmcodes geschieht auf Ihre eigene Verantwortung. Microsoft stellt Ihnen diese Informationen sowie Makro- und Programmlistings ohne Gewähr auf Richtigkeit, Vollständigkeit und/oder Funktionalität sowie ohne Anspruch auf Support zur Verfügung. In diesem Artikel wird vorausgesetzt, dass Sie mit der in den Beispielen verwendeten Programmiersprache und mit den zum Erstellen und Debuggen von Prozeduren verwendeten Tools vertraut sind. Die Mitarbeiter der Microsoft Product Support Services erklären Ihnen gerne die Funktionsweise einer bestimmten Prozedur. Die Mitarbeiter werden diese Beispiele jedoch weder modifizieren, um zusätzliche Funktionalität zu schaffen, noch Prozeduren entwickeln, die auf Ihre spezifischen Bedürfnisse zugeschnitten sind.


function Invoke-PasswordRoll
{
<#
.ZUSAMMENFASSUNG

Dieses Skript kann verwendet werden, um die Kennwörter lokaler Konten auf Remotecomputern auf zufällig gewählte Kennwörter festzulegen. Die Benutzername/Kennwort/Server-Kombination wird in einer CSV-Datei gespeichert.
Die in der CSV-Datei gespeicherten Kontokennwörter können mit einem vom Administrator gewählten Kennwort verschlüsselt werden, um sicherzustellen, dass die Kontokennwörter nicht als Klartextdaten auf den Datenträger geschrieben werden.
Die verschlüsselten Kennwörter können mit einer anderen Funktion dieser Datei entschlüsselt werden: ConvertTo-CleartextPassword


Funktion: Invoke-PasswordRoll
Autor: Microsoft
Version: 1.0

.BESCHREIBUNG

Dieses Skript kann verwendet werden, um die Kennwörter lokaler Konten auf Remotecomputern auf zufällig gewählte Kennwörter festzulegen. Die Benutzername/Kennwort/Server-Kombination wird in einer CSV-Datei gespeichert.
Die in der CSV-Datei gespeicherten Kontokennwörter können mit einem vom Administrator gewählten Kennwort verschlüsselt werden, um sicherzustellen, dass die Kontokennwörter nicht als Klartextdaten auf den Datenträger geschrieben werden.
Die verschlüsselten Kennwörter können mit einer anderen Funktion dieser Datei entschlüsselt werden: ConvertTo-CleartextPassword

.PARAMETER ComputerName

Ein Array von Computern, auf denen das Skript mit PowerShell-Remoting ausgeführt werden soll.

.PARAMETER LocalAccounts

Ein Array von lokalen Konten, deren Kennwort geändert werden soll.

.PARAMETER TsvFileName

Die Datei, in die die Benutzername/Kennwort/Server-Kombinationen ausgegeben werden.

.PARAMETER EncryptionKey

Ein Kennwort zum Verschlüsseln der TSV-Datei. Verwendet AES-Verschlüsselung Nur die in der TSV-Datei gespeicherten Kennwörter werden verschlüsselt, Benutzername und Servername bleiben Klartextdaten.

.PARAMETER PasswordLength

Die Länge der Kennwörter, die zufällig für lokale Konten generiert werden.

.PARAMETER NoEncryption

Die in der TSV-Datei gespeicherten Kontokennwörter werden nicht verschlüsselt. Dadurch werden Klartext-Kennwörter auf den Datenträger geschrieben.

.BEISPIEL

. .\Invoke-PasswordRoll.ps1 #Lädt die Funktionen in dieser Skriptdatei
Invoke-PasswordRoll -ComputerName (Get-Content computerlist.txt) -LocalAccounts @("administrator","CustomLocalAdmin") -TsvFileName "LocalAdminCredentials.tsv" -EncryptionKey "Password1"

Stellt Verbindungen mit allen in der Datei "computerlist.txt" gespeicherten Computern her. Wenn das lokale Konto "Administrator" und/oder das Konto "CustomLocalAdmin" auf dem System vorhanden sind, wird deren Kennwort
in ein zufällig generiertes, 20 Zeichen (Standard) langes Kennwort geändert. Die Benutzername/Kennwort/Server-Kombinationen werden in der Datei "LocalAdminCredentials.tsv" gespeichert, und die Kontokennwörter werden mit der AES-Verschlüsselung unter Verwendung des Kennworts "Password1" verschlüsselt.

.BEISPIEL

. .\Invoke-PasswordRoll.ps1 #Lädt die Funktionen in dieser Skriptdatei
Invoke-PasswordRoll -ComputerName (Get-Content computerlist.txt) -LocalAccounts @("administrator") -TsvFileName "LocalAdminCredentials.tsv" -NoEncryption -PasswordLength 40

Stellt Verbindungen mit allen in der Datei "computerlist.txt" gespeicherten Computern her. Wenn das lokale Konto "Administrator" auf dem System vorhanden ist, wird dessen Kennwort in ein zufällig generiertes,
40 Zeichen langes Kennwort geändert. Die Benutzername/Kennwort/Server-Kombinationen werden in der Datei "LocalAdminCredentials.tsv" unverschlüsselt gespeichert.

.HINWEISE
Voraussetzungen:
-PowerShellv2 oder höher müssen installiert sein.
-PowerShell-Remoting muss auf allen Systemen, für die das Skript ausgeführt wird, aktiviert sein.

Skriptverhalten:
-Wenn auf dem System ein lokales Konto vorhanden, aber nicht im LocalAccounts-Parameter angegeben worden ist, dann gibt das Skript eine Warnung auf dem Bildschirm aus, um Sie auf dieses lokale Konto aufmerksam zu machen. Das Skript wird in diesem Fall weiter ausgeführt.
-Wenn im LocalAccounts-Parameter ein lokales Konto angegeben wurde, das Konto aber nicht auf dem Computer vorhanden ist, dann geschieht nichts (es wird KEIN Konto erstellt).
-MIt der in dieser Datei enthaltenen Funktion ConvertTo-CleartextPassword können die Kennwörter, die verschlüsselt in der TSV-Datei gespeichert werden, entschlüsselt werden.
-Wenn mit einem in ComputerName angegebenen Computer keine Verbindung hergestellt werden kann, gibt PowerShell eine Fehlermeldung aus.
-Microsoft empfiehlt Firmen, die Kennwörter für alle lokalen Konten und Domänenkonten regelmäßig zu ändern.

#>
[CmdletBinding(DefaultParameterSetName="Encryption")]
Param(
[Parameter(Mandatory=$true)]
[String[]]
$ComputerName,

[Parameter(Mandatory=$true)]
[String[]]
$LocalAccounts,

[Parameter(Mandatory=$true)]
[String]
$TsvFileName,

[Parameter(ParameterSetName="Encryption", Mandatory=$true)]
[String]
$EncryptionKey,

[Parameter()]
[ValidateRange(20,120)]
[Int]
$PasswordLength = 20,

[Parameter(ParameterSetName="NoEncryption", Mandatory=$true)]
[Switch]
$NoEncryption
)


#Alle erforderlichen .net-Klassen laden
Add-Type -AssemblyName "System.Web" -ErrorAction Stop


#Dieser Skriptblock wird auf jedem in ComputerName angegebenen Computer ausgeführt
$RemoteRollScript = {
Param(
[Parameter(Mandatory=$true, Position=1)]
[String[]]
$Passwords,

[Parameter(Mandatory=$true, Position=2)]
[String[]]
$LocalAccounts,

#Hiermit kann der Servername aufgezeichnet werden, mit dem das Skript verbunden war, damit er verfügbar ist, wenn die DNS-Einträge fehlerhaft sind.
[Parameter(Mandatory=$true, Position=3)]
[String]
$TargettedServerName
)

$LocalUsers = Get-WmiObject Win32_UserAccount -Filter "LocalAccount=true" | Foreach {$_.Name}

#Prüfen, ob auf dem Computer lokale Benutzerkonten vorhanden sind, deren Kennwörter nicht durch dieses Skript geändert werden
foreach ($User in $LocalUsers)
{
if ($LocalAccounts -inotcontains $User)
{
Write-Warning "Server: '$($TargettedServerName)' hast ein lokales Konto '$($User)' dessen Kennwort NICHT durch dieses Skript geändert wird"
}
}

#Das Kennwort für jedes angegebene lokale Konto ändern, das auf diesem Server vorhanden ist
$PasswordIndex = 0
foreach ($LocalAdmin in $LocalAccounts)
{
$Password = $Passwords[$PasswordIndex]

if ($LocalUsers -icontains $LocalAdmin)
{
try
{
$objUser = [ADSI]"WinNT://localhost/$($LocalAdmin), user"
$objUser.psbase.Invoke("SetPassword", $Password)

$Properties = @{
TargettedServerName = $TargettedServerName
Username = $LocalAdmin
Password = $Password
RealServerName = $env:computername
}

$ReturnData = New-Object PSObject -Property $Properties
Write-Output $ReturnData
}
catch
{
Write-Error "Fehler beim Ändern des Kennworts für den Benutzer:$($LocalAdmin) auf dem Server:$($TargettedServerName)"
}
}

$PasswordIndex++
}
}


#Das Kennwort auf dem Client, auf dem dieses Skript ausgeführt wird, und nicht auf dem Remotecomputer generieren System.Web.Security ist im .NET-Clientprofil nicht verfügbar. Durch diesen Aufruf
# wird auf dem Client, auf dem das Skript ausgeführt wird, sichergestellt, dass .NET Runtime nur auf 1 Computer (statt auf allen Systemen, auf denen das Kennwort geändert wird) vollständig installiert werden muss.
function Create-RandomPassword
{
Param(
[Parameter(Mandatory=$true)]
[ValidateRange(20,120)]
[Int]
$PasswordLength
)

$Password = [System.Web.Security.Membership]::GeneratePassword($PasswordLength, $PasswordLength / 4)

#Dies sollte nie fehlschlagen, aber sicherheitshalber wird hier trotzdem eine Funktionsüberprüfung eingefügt
if ($Password.Length -ne $PasswordLength)
{
throw new Exception("Das von GeneratePassword zurückgegebene Kennwort hat nicht die erforderliche Länge. Erforderliche Länge: $($PasswordLength). Generierte Länge: $($Password.Length)")
}

return $Password
}


#Hauptfunktion - Kennwort generieren und an Computer übertragen, um das Kennwort der angegebenen lokalen Konten zu ändern
if ($PsCmdlet.ParameterSetName -ieq "Encryption")
{
try
{
$Sha256 = new-object System.Security.Cryptography.SHA256CryptoServiceProvider
$SecureStringKey = $Sha256.ComputeHash([System.Text.UnicodeEncoding]::Unicode.GetBytes($EncryptionKey))
}
catch
{
Write-Error "Fehler beim Erstellen des TSV-Verschlüsselungsschlüssel" -ErrorAction Stop
}
}

foreach ($Computer in $ComputerName)
{
#Für jedes Konto, das geändert werden kann, muss 1 Kennwort generiert werden
$Passwords = @()
for ($i = 0; $i -lt $LocalAccounts.Length; $i++)
{
$Passwords += Create-RandomPassword -PasswordLength $PasswordLength
}

Write-Output "Verbindung herstellen mit Server '$($Computer)' zum Zurücksetzen der angegebenen lokalen Administratorkennwörter"
$Result = Invoke-Command -ScriptBlock $RemoteRollScript -ArgumentList @($Passwords, $LocalAccounts, $Computer) -ComputerName $Computer
#Wenn Verschlüsselung gewünscht ist, das Kennwort mit dem vom Benutzer angegebenen Kennwort verschlüsseln, bevor es auf den Datenträger geschrieben wird
if ($Result -ne $null)
{
if ($PsCmdlet.ParameterSetName -ieq "NoEncryption")
{
$Result | Select-Object Username,Password,TargettedServerName,RealServerName | Export-Csv -Append -Path $TsvFileName -NoTypeInformation
}
else
{
#Filters out $null entries returned
$Result = $Result | Select-Object Username,Password,TargettedServerName,RealServerName

foreach ($Record in $Result)
{
$PasswordSecureString = ConvertTo-SecureString -AsPlainText -Force -String ($Record.Password)
$Record | Add-Member -MemberType NoteProperty -Name EncryptedPassword -Value (ConvertFrom-SecureString -Key $SecureStringKey -SecureString $PasswordSecureString)
$Record.PSObject.Properties.Remove("Password")
$Record | Select-Object Username,EncryptedPassword,TargettedServerName,RealServerName | Export-Csv -Append -Path $TsvFileName -NoTypeInformation
}
}
}
}
}


function ConvertTo-CleartextPassword
{
<#
.ZUSAMMENFASSUNG
Mit dieser Funktion können Kennwörter entschlüsselt werden, die von der Funktion Invoke-PasswordRoll verschlüsselt gespeichert wurden.

Funktion: ConvertTo-CleartextPassword
Autor: Microsoft
Version: 1.0

.BESCHREIBUNG
Mit dieser Funktion können Kennwörter entschlüsselt werden, die von der Funktion Invoke-PasswordRoll verschlüsselt gespeichert wurden.


.PARAMETER EncryptedPassword

Das verschlüsselte Kennwort, das in einer TSV-Datei gespeichert wurde.

.PARAMETER EncryptionKey

Das zum Verschlüsseln verwendete Kennwort.


.BEISPIEL

. .\Invoke-PasswordRoll.ps1 #Lädt die Funktionen in dieser Skriptdatei
ConvertTo-CleartextPassword -EncryptionKey "Password1" -EncryptedPassword 76492d1116743f0423413b16050a5345MgB8AGcAZgBaAHUAaQBwADAAQgB2AGgAcABNADMASwBaAFoAQQBzADEAeABjAEEAPQA9AHwAZgBiAGYAMAA1ADYANgA2ADEANwBkADQAZgAwADMANABjAGUAZQAxAGIAMABiADkANgBiADkAMAA4ADcANwBhADMAYQA3AGYAOABkADcAMQA5ADQAMwBmAGYANQBhADEAYQBjADcANABkADIANgBhADUANwBlADgAMAAyADQANgA1ADIAOQA0AGMAZQA0ADEAMwAzADcANQAyADUANAAzADYAMAA1AGEANgAzADEAMQA5ADAAYwBmADQAZAA2AGQA"

Entschlüsselt das verschlüsselte Kennwort, das in der TSV-Datei gespeichert wurde.

#>
Param(
[Parameter(Mandatory=$true)]
[String]
$EncryptedPassword,

[Parameter(Mandatory=$true)]
[String]
$EncryptionKey
)

$Sha256 = new-object System.Security.Cryptography.SHA256CryptoServiceProvider
$SecureStringKey = $Sha256.ComputeHash([System.Text.UnicodeEncoding]::Unicode.GetBytes($EncryptionKey))

[SecureString]$SecureStringPassword = ConvertTo-SecureString -String $EncryptedPassword -Key $SecureStringKey
Write-Output ([System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToCoTaskMemUnicode($SecureStringPassword)))
}
 Administratoren können Computern lokale Administratorkonten hinzufügen, indem Sie eine Active Directory-Gruppe erstellen und diese über "Gruppenrichtlinieneinstellungen -> Lokale Gruppe" der lokalen Gruppe "Administratoren" hinzufügen. Dabei werden keine Anmeldeinformationen zwischengespeichert. Das Dialogfeld ähnelt dem Folgenden. Diese Problemumgehung erfordert eine Verbindung mit Active Directory-Domänendienste, wenn der Benutzer mit diesen Anmeldeinformationen angemeldet ist.

Wichtige Änderungen

Aktion: Erstellen, Aktualisieren oder Ersetzen

• Die Felder Benutzername, Kennwort und Kennwort bestätigen sind deaktiviert.

Aktion: Löschen

• Keine Änderung im Verhalten

Problemumgehungen

Statt Kennwörter zum Authentifizieren zu verwenden, können Sie mit Windows-Explorer Freigabeberechtigungen verwalten und Benutzern Rechte zuteilen. Sie können mit Active Directory-Objekten Berechtigungen für Ordner steuern.

Wichtige Änderungen

Starten: Keine Änderung, Automatisch oder Manuell

• Die Felder Kennwort und Kennwort bestätigen sind deaktiviert.

• Der Administrator kann nur die integrierten Konten verwenden.

Starten: Deaktivieren

• Keine Änderung im Verhalten

Neues Dialogfeld

• Administratoren, die für dieses Konto nicht integrierte Benutzer verwenden möchten, erhalten die folgende Warnung:

Problemumgehungen

Dienste können noch als lokales Systemkonto ausgeführt werden. Die Dienstberechtigungen können wie im folgenden Artikel der Microsoft Knowledge Base beschrieben geändert werden:

256345 Konfigurieren von Gruppenrichtlinien zum Einrichten der Sicherheit für Systemdienste

Hinweis Wenn der Dienst, den Sie konfigurieren möchten, nicht vorhanden ist, müssen Sie die Einstellungen auf einem Computer konfigurieren, auf dem der Dienst ausgeführt wird.

Wichtige Änderungen

Aktion: Erstellen, Aktualisieren oder Ersetzen

• Wenn Sie die Option Unabhängig von der Benutzeranmeldung ausführen aktivieren, wird der Administrator nicht mehr durch ein Dialogfeld zur Eingabe von Anmeldeinformationen aufgefordert.

• Die Option Kennwort nicht speichern ist deaktiviert. Standardmäßig ist auch diese Option aktiviert.

Aktion: Löschen

Keine Änderung im Verhalten

Problemumgehungen

Für die Aufgaben "Geplante Aufgabe (mindestens Windows 7)" und "Sofortige Aufgabe (mindestens Windows 7)" können Administratoren bestimmte Benutzerkonten verwenden, wenn der betreffende Benutzer angemeldet ist. Oder sie können als der betreffende Benutzer nur Zugriff auf lokale Ressourcen haben. Diese Aufgaben können weiterhin im Kontext des lokalen Diensts ausgeführt werden.

Wichtige Änderungen

Aktion: Erstellen, Aktualisieren oder Ersetzen

• Das Kontrollkästchen Ausführen als ist deaktiviert. Daher sind die Felder Benutzername, Kennwort und Kennwort bestätigen deaktiviert.

Aktion: Löschen

Keine Änderung im Verhalten

Problemumgehungen

Für die Optionen "Geplante Aufgabe" und "Sofortige Aufgabe (Windows XP)" werden geplante Aufgaben mit den Berechtigungen ausgeführt, die derzeit für den lokalen Dienst verfügbar sind.

Wichtige Änderungen

Aktion: Erstellen, Aktualisieren oder Ersetzen

• Die Felder Benutzername, Kennwort und Kennwort bestätigen sind deaktiviert:

Aktion: Löschen

• Keine Änderung im Verhalten

Problemumgehungen

Es sind keine Problemumgehungen verfügbar. In dieser Einstellung werden keine Anmeldeinformationen mehr gespeichert, um den Zugriff auf kennwortgeschützte Datenquellen zu ermöglichen.

Erkennen von CPassword-Einstellungen

Dieses Skript muss aus einem lokalen Verzeichnis auf dem zu bereinigenden Domänencontroller heraus ausgeführt werden. Kopieren Sie den Inhalt, und speichern Sie ihn in einer neuen Windows PowerShell-Datei. Bestimmen Sie Ihr Systemlaufwerk, und führen Sie das Skript dann wie im Folgenden beschrieben aus.

<#
.ZUSAMMENFASSUNG
Gruppenrichtlinienobjekte in der Domäne können Einstellungen haben, in denen Kennwörter für verschiedene Aufgaben gespeichert werden, beispielsweise:
1. Datenquellen
2. Laufwerkzuordnungen
3. Lokale Benutzer
4. Geplante Aufgaben (sowohl XP als auch höhere Ebenen)
5. Dienste
Diese Kennwörter werden in SYSVOL als Teil der Gruppenrichtlinieneinstellungen gespeichert und sind wegen der schwachen Verschlüsselung (32-Byte-AES) nicht sicher.
Aus diesem Grund wird empfohlen, solche Einstellungen nicht in der Domänenumgebung bereitzustellen und ggf. vorhandene
Einstellungen zu entfernen. Dieses Skript soll Administratoren helfen, die Gruppenrichtlinieneinstellungen, welche Kennwörter enthalten, im SYSVOL ihrer Domäne zu finden.

.BESCHREIBUNG
Dieses Skript sollte auf einem Domänencontroller oder Clientcomputer ausgeführt werden, auf dem RSAT installiert worden ist, damit alle Einstellungen, die
Kennwörter enthalten, zusammen mit anderen Informationen ausgedruckt werden können, wie Gruppenrichtlinienobjekt, Name der Einstellung, Gruppenrichtlinien-Editor-Pfad, unter dem diese Einstellung definiert ist.
Sobald Sie eine Liste der betroffenen Einstellungen haben, können Sie die Einstellungen mit dem Editor in der Gruppenrichtlinien-Verwaltungskonsole entfernen.

.SYNTAX
Get-SettingsWithCPassword.ps1 [-Path <String>]
.BEISPIEL
Get-SettingsWithCPassword.ps1 -Path %WinDir%\SYSVOL\domain
Get-SettingsWithCPassword.ps1 -Path <Pfad des Sicherungsordners für Gruppenrichtlinienobjekte>

.HINWEISE
Wenn das Gruppenrichtlinien-PS-Modul nicht gefunden wird, enthält die Ausgabe die GUIDs der Gruppenrichtlinienobjekte statt deren Namen. Sie können
dieses Skript entweder auf einem Domänencontroller ausführen oder es nach der Installation von RSAT und
der Aktivierung des Gruppenrichtlinienmoduls erneut auf dem Client ausführen.
Stattdessen können Sie auch mit dem Cmdlet Get-GPO anhand der GUIDs der Gruppenrichtlinienobjekte deren Namen ermitteln.

.LINK
http://go.microsoft.com/fwlink/?LinkID=390507

#>
#----------------------------------------------------------------------------------------------------------------
# Eingabeparameter
#--------------------------------------------------------------------------------------------------------------
param(
[string]$Path = $(throw "-Path is required.") # Verzeichnispfad der Gruppenrichtlinieneinstellungen.
)
#---------------------------------------------------------------------------------------------------------------
$isGPModuleAvailable = $false
$impactedPrefs = { "Groups.xml", "ScheduledTasks.xml","Services.xml", "DataSources.xml", "Drives.xml" }
#----------------------------------------------------------------------------------------------------------------
# Gruppenrichtlinienmodul importieren, falls verfügbar
#----------------------------------------------------------------------------------------------------------------
if (-not (Get-Module -name "GroupPolicy"))
{
if (Get-Module -ListAvailable |
Where-Object { $_.Name -ieq "GroupPolicy" })
{
$isGPModuleAvailable = $true
Import-Module "GroupPolicy"
}
else
{
Write-Warning "Gruppenrichtlinienmodul kann nicht für PowerShell importiert werden. Daher werden Gruppenrichtlinienobjekt-Guids gemeldet.
Führen Sie dieses Skript auf dem Domänencontroller aus, um die Gruppenrichtlinienobjektnamen abzurufen, oder wenden Sie das Cmdlet Get-GPO (auf dem Domänencontroller) aus, um den Gruppenrichtlinienobjektnamen für eine Gruppenrichtlinienobjekt-Guid zu ermitteln."
}
}
else
{
$isGPModuleAvailable = $true
}
Function Enum-SettingsWithCpassword ( [string]$sysvolLocation )
{
# GPMC tree paths
$commonPath = " -> Preferences -> Control Panel Settings -> "
$driveMapPath = " -> Preferences -> Windows Settings -> "

# Rekursiv alle XML-Dateien innerhalb des Speicherorts SYVOL abrufen
$impactedXmls = Get-ChildItem $sysvolLocation -Recurse -Filter "*.xml" | Where-Object { $impactedPrefs -cmatch $_.Name }


# Jede XML-Datei enthält mehrere Einstellungen. Überprüfen Sie die einzelnen Einstellungen daraufhin, ob sie
# das cpassword-Attribut enthalten, und das Attribut ggf. anzeigen.
foreach ( $file in $impactedXmls )
{
$fileFullPath = $file.FullName

# GPP-Kategorie festlegen. Wenn sich die Datei unter dem Ordner "Computer" im SYSVOL befindet,
# ist die Einstellung unter Computerkonfiguration definiert,
# sonst ist sie eine Benutzerkonfiguration.
if ( $fileFullPath.Contains("Machine") )
{
$category = "Computer Configuration"
}
elseif ( $fileFullPath.Contains("User") )
{
$category = "User Configuration"
}
else
{
$category = "Unknown"
}
# Dateiinhalt als XML abrufen
try
{
[xml]$xmlFile = get-content $fileFullPath -ErrorAction Continue
}
catch [Exception]{
Write-Host $_.Exception.Message
}
if ($xmlFile -eq $null)
{
continue
}
switch ( $file.BaseName )
{
Groups
{
$gppWithCpassword = $xmlFile.SelectNodes("Groups/User") | where-Object { [String]::IsNullOrEmpty($_.Properties.cpassword) -eq $false }
$preferenceType = "Local Users"
}
ScheduledTasks
{
$gppWithCpassword = $xmlFile.SelectNodes("ScheduledTasks/*") | where-Object { [String]::IsNullOrEmpty($_.Properties.cpassword) -eq $false }
$preferenceType = "Scheduled Tasks"
}
DataSources
{
$gppWithCpassword = $xmlFile.SelectNodes("DataSources/DataSource") | where-Object { [String]::IsNullOrEmpty($_.Properties.cpassword) -eq $false }
$preferenceType = "Data sources"
}
Drives
{
$gppWithCpassword = $xmlFile.SelectNodes("Drives/Drive") | where-Object { [String]::IsNullOrEmpty($_.Properties.cpassword) -eq $false }
$preferenceType = "Drive Maps"
}
Services
{
$gppWithCpassword = $xmlFile.SelectNodes("NTServices/NTService") | where-Object { [String]::IsNullOrEmpty($_.Properties.cpassword) -eq $false }
$preferenceType = "Services"
}
default
{ # gppWithCpassword und preferenceType für das nächste Element löschen.
try
{
Clear-Variable -Name gppWithCpassword -ErrorAction SilentlyContinue
Clear-Variable -Name preferenceType -ErrorAction SilentlyContinue
}
catch [Exception]{}
}
}
if ($gppWithCpassword -ne $null)
{
# Name des Gruppenrichtlinienobjekts anhand der GUID ermitteln, die aus filePath extrahiert wurde
$guidRegex = [regex]"\{(.*)\}"
$match = $guidRegex.match($fileFullPath)
if ($match.Success)
{
$gpoGuid = $match.groups[1].value
$gpoName = $gpoGuid
}
else
{
$gpoName = "Unknown"
}
if($isGPModuleAvailable -eq $true)
{
try
{
$gpoInfo = Get-GPO -Guid $gpoGuid -ErrorAction Continue
$gpoName = $gpoInfo.DisplayName
}
catch [Exception] {
Write-Host $_.Exception.Message
}
}
# Einstellungen anzeigen, die cpassword enthalten
foreach ( $gpp in $gppWithCpassword )
{
if ( $preferenceType -eq "Drive Maps" )
{
$prefLocation = $category + $driveMapPath + $preferenceType
}
else
{
$prefLocation = $category + $commonPath + $preferenceType
}
$obj = New-Object -typeName PSObject
$obj | Add-Member –membertype NoteProperty –name GPOName –value ($gpoName) –passthru |
Add-Member -MemberType NoteProperty -name Preference -value ($gpp.Name) -passthru |
Add-Member -MemberType NoteProperty -name Path -value ($prefLocation)
Write-Output $obj
}
} # end if $gppWithCpassword
} # end foreach $file
} # end functions Enum-PoliciesWithCpassword
#-----------------------------------------------------------------------------------
# Prüfen, ob Pfad gültig ist. Alle Einstellungen auflisten, die cpassword enthalten.
#-----------------------------------------------------------------------------------
if (Test-Path $Path )
{
Enum-SettingsWithCpassword $Path
}
else
{
Write-Warning "Verzeichnis nicht vorhanden: $Path"
}


Beispielsyntax (setzt voraus, dass C das Systemlaufwerk ist)

.\Get-SettingsWithCPassword.ps1 –path “C:\Windows\SYSVOL\domain” | Format-List
Hinweis Beachten Sie, dass Sie statt der Domäne auch ein Sicherungsgruppenrichtlinienobjekt als Ziel für path angeben können.

Das Erkennungsskript erzeugt eine Liste, die der folgenden Liste ähnelt:



Bei längeren Listen sollten sie die Ausgabe in einer Datei speichern:

.\Get-SettingsWithCPassword.ps1 –path “C:\Windows\SYSVOL\domain” | ConvertTo-Html > gpps.html

Entfernen von CPassword-Einstellungen

Zum Entfernen der Einstellungen, die CPassword-Daten enthalten, wird empfohlen, die Gruppenrichtlinien-Verwaltungskonsole (GPMC) auf dem Domänencontroller bzw. auf einem Client, auf dem die Remoteserver-Verwaltungstools installiert sind, zu verwenden. Sie können auf diesen Konsolen jede Einstellung mit fünf Schritten entfernen. Gehen Sie hierzu wie folgt vor:

1. Öffnen Sie in der Gruppenrichtlinien-Verwaltungskonsole die Einstellung, die CPassword-Daten enthält.

2. Ändern Sie die Aktion in Löschen oder Deaktivieren, je nachdem, was für die betreffende Einstellung geeignet ist.

3. Klicken Sie auf OK, um Ihre Änderungen zu speichern.

4. Warten Sie ein oder zwei Gruppenrichtlinien Aktualisierungszyklen ab, damit die Änderungen an die Clients weitergegeben werden können.

5. Nachdem die Änderungen auf alle Clients angewendet worden sind, löschen Sie die Einstellung.

6. Wiederholen Sie die Schritte 1 bis 5 nach Bedarf, um die gesamte Umgebung zu bereinigen. Wenn das Erkennungsskript keine Ergebnisse zurückgibt, sind Sie fertig.