MS14-025: Uma vulnerabilidade nas preferências da Política de Grupo pode permitir a elevação de privilégio: 13 de maio de 2014

Alterações importantes

Ação: Criar ou Substituir

• Os campos Nome de usuário, Senha e Confirmar senha estão desabilitados.

• A caixa de diálogo de aviso aparece quando o administrador abre ou tenta salvar qualquer alteração para uma preferência existente que contém uma senha.

Ação: Atualizar

• Os campos Senha e Confirmar senha estão desabilitados.

• A caixa de diálogo de aviso aparece quando o administrador abre ou tenta salvar qualquer alteração para uma preferência existente que contém uma senha.

Ação: Excluir

• Nenhuma alteração no comportamento

Soluções alternativas

Para aqueles que antes dependiam da preferência da Política de grupo para definir senhas de administrador local, o script a seguir é fornecido como uma alternativa segura ao CPassword. Copie e salve o conteúdo em um novo arquivo do Windows PowerShell e depois execute o script conforme indicado na seção .EXAMPLE.

A Microsoft fornece exemplos de programação apenas por questões ilustrativas, sem garantias expressas ou implícitas. Isso inclui (mas não está limitado a) garantias implícitas de comercialização ou adequação a um determinado propósito. Este artigo pressupõe que você conhece a linguagem de programação demonstrada e também as ferramentas usadas para criar e depurar procedimentos. Os engenheiros de suporte da Microsoft podem ajudá-lo, fornecendo a explicação da funcionalidade de um determinado procedimento. Entretanto, eles não modificarão esses exemplos para fornecer funcionalidades adicionais ou criar procedimentos específicos para atender às suas necessidades específicas.


function Invoke-PasswordRoll
{
<#
.SYNOPSIS

Esse script pode ser usado para definir as senhas de conta local em máquinas remotas para senhas aleatórias. A combinação de nome de usuário/senha/servidor será salva em um arquivo CSV.
As senhas da conta armazenadas no arquivo CSV podem ser criptografadas usando uma senha de administradores que optaram por assegurar que as senhas de conta não criptografadas não sejam gravadas no disco.
As senhas criptografadas podem ser descriptografadas usando outra função neste arquivo: ConvertTo-CleartextPassword


Função: Invoke-PasswordRoll
Autor: Microsoft
Versão: 1.0

.DESCRIÇÃO

Esse script pode ser usado para definir as senhas de conta local em máquinas remotas para senhas aleatórias. A combinação de nome de usuário/senha/servidor será salva em um arquivo CSV.
As senhas da conta armazenadas no arquivo CSV podem ser criptografadas usando uma senha de administradores que optaram por assegurar que as senhas de conta não criptografadas não sejam gravadas no disco.
As senhas criptografadas podem ser descriptografadas usando outra função neste arquivo: ConvertTo-CleartextPassword

.PARÂMETRO ComputerName

Uma matriz de computadores para executar o script usando a comunicação remota do PowerShell.

.PARÂMETRO LocalAccounts

Uma matriz de contas locais cujas senhas devem ser alteradas.

.PARÂMETRO TsvFileName

O arquivo para inserir as combinações de senha/nome de usuário/servidor.

.PARÂMETRO EncryptionKey

Uma senha para criptografar o arquivo TSV. Usa a criptografia AES. Somente as senhas armazenadas no arquivo TSV serão criptografadas, o nome do usuário e o nome do servidor não serão criptografados.

.PARÂMETRO PasswordLength

O comprimento das senhas que serão geradas aleatoriamente para contas locais.

.PARÂMETRO NoEncryption

Não criptografe as senhas de conta armazenadas no arquivo TSV. Isso resultará em senhas de texto não criptografado sendo gravadas no disco.

.EXEMPLO

. .\Invoke-PasswordRoll.ps1 #Carrega as funções no arquivo de script
Invoke-PasswordRoll -ComputerName (Get-Content computerlist.txt) -LocalAccounts @("administrator","CustomLocalAdmin") -TsvFileName "LocalAdminCredentials.tsv" -EncryptionKey "Password1"

Conecta-se a todos os computadores armazenados no arquivo "computerlist.txt". Se a conta local "administrador" e/ou "CustomLocalAdmin" estão presentes no sistema, a senha é alterada
para uma senha gerada aleatoriamente de comprimento 20 (o padrão). As combinações de nome de usuário/senha/servidor são armazenadas em LocalAdminCredentials.tsv e as senhas de conta são criptografadas usando o AES com a senha "Senha1".

.EXEMPLO

. .\Invoke-PasswordRoll.ps1 #Carrega as funções no arquivo de script
Invoke-PasswordRoll -ComputerName (Get-Content computerlist.txt) -LocalAccounts @("administrator") -TsvFileName "LocalAdminCredentials.tsv" -NoEncryption -PasswordLength 40

Conecta-se a todos os computadores armazenados no arquivo "computerlist.txt". Se a conta local "administrador" está presente no sistema, a senha é alterada para uma gerada aleatoriamente,
de comprimento 40. As combinações de senha/nome de usuário/servidor são armazenadas em LocalAdminCredentials.tsv sem criptografia.

.OBSERVAÇÕES
Requisitos:
-PowerShellv2 ou superior deve ser instalado
-Conexão remota do PowerShell deve ser habilitada em todos os sistemas em que o script será executado

Comportamento de script:
-Se uma conta local está presente no sistema, mas não está especificada no parâmetro LocalAccounts, o script gravará um aviso na tela para alertar você da presença desta conta local. O script continuará executando quando isso acontece.
-Se uma conta local é especificada no parâmetro LocalAccounts, mas a conta não existe no computador, nada acontecerá (uma conta NÃO será criada).
-A função ConvertTo-CleartextPassword, contida neste arquivo, pode ser usada para descriptografar senhas que são armazenadas criptografadas no arquivo TSV.
-Se um servidor especificado no ComputerName não pode ser conectado, o PowerShell irá gerar uma mensagem de erro.
-A Microsoft aconselha as empresas para reverter regularmente todas as senhas de contas locais e de domínio.

#>
[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
)


#Carregar qualquer classe .net necessária
Add-Type -AssemblyName "System.Web" -ErrorAction Stop


#Este é o scriptblock que será executado em todos os computadores especificados em ComputerName
$RemoteRollScript = {
Param(
[Parameter(Mandatory=$true, Position=1)]
[String[]]
$Passwords,

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

#Isto está aqui para que eu possa registrar qual o nome do servidor que no qual o script estava conectado, às vezes os registros DNS causam problemas, pode ser bom ter isso.
[Parameter(Mandatory=$true, Position=3)]
[String]
$TargettedServerName
)

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

#Verifique se o computador tem qualquer conta de usuário local cujas senhas não serão revertidas por este script.
foreach ($User in $LocalUsers)
{
if ($LocalAccounts -inotcontains $User)
{
Write-Warning "Servidor: '$($TargettedServerName)' possui uma conta local '$($User)' cuja senha NÃO está sendo alterada por este script"
}
}

#For cada conta local especificada que existe no servidor, altere a senha
$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 "Erro ao alterar senha para o usuário:$($LocalAdmin) no servidor:$($TargettedServerName)"
}
}

$PasswordIndex++
}
}


#Gere a senha no cliente que está executando esse script, não no computador remoto. O System.Web.Security não está disponível no perfil de Cliente .NET. Fazer esta chamada
# no cliente que está executando o script garante que somente o computador 1 precisa de um tempo de execução .NET completo instalado (ao contrário de todos os sistemas que têm a senha revertida).
function Create-RandomPassword
{
Param(
[Parameter(Mandatory=$true)]
[ValidateRange(20,120)]
[Int]
$PasswordLength
)

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

#Isto não deveria falhar nunca, mas eu estou colocando uma verificação de integridade aqui mesmo assim
if ($Password.Length -ne $PasswordLength)
{
throw new Exception("Senha retornada por GeneratePassword não tem o comprimento exigido. Comprimento exigido: $($PasswordLength). Comprimento gerado: $($Password.Length)")
}

return $Password
}


#Funcionalidade principal - Gere uma senha e faça uma comunicação remota com as máquinas para alterar a senha de contas locais especificadas.
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 "Erro ao criar chave de criptografia TSV" -ErrorAction Stop
}
}

foreach ($Computer in $ComputerName)
{
#Necessidade de gerar 1 senha para cada conta que pode ser alterada
$Passwords = @()
for ($i = 0; $i -lt $LocalAccounts.Length; $i++)
{
$Passwords += Create-RandomPassword -PasswordLength $PasswordLength
}

Write-Output "Conectando-se ao servidor '$($Computer)' para reverter as senhas de administrador local especificado"
$Result = Invoke-Command -ScriptBlock $RemoteRollScript -ArgumentList @($Passwords, $LocalAccounts, $Computer) -ComputerName $Computer
#Se a criptografia estiver sendo usada, criptografar a senha com a chave antes de gravar no disco
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
{
<#
.SYNOPSIS
Esta função pode ser usada para descriptografar as senhas que foram armazenadas criptografadas pela função Invoke-PasswordRoll.

Função: ConvertTo-CleartextPassword
Autor: Microsoft
Versão: 1.0

.DESCRIÇÃO
Esta função pode ser usada para descriptografar as senhas que foram armazenadas criptografadas pela função Invoke-PasswordRoll.


.PARÂMETRO EncryptedPassword

A senha criptografada armazenada em um arquivo TSV.

.PARÂMETRO EncryptionKey

A senha usada para fazer a criptografia.


.EXEMPLO

. .\Invoke-PasswordRoll.ps1 #Carrega as funções no arquivo de script
ConvertTo-CleartextPassword -EncryptionKey "Password1" -EncryptedPassword 76492d1116743f0423413b16050a5345MgB8AGcAZgBaAHUAaQBwADAAQgB2AGgAcABNADMASwBaAFoAQQBzADEAeABjAEEAPQA9AHwAZgBiAGYAMAA1ADYANgA2ADEANwBkADQAZgAwADMANABjAGUAZQAxAGIAMABiADkANgBiADkAMAA4ADcANwBhADMAYQA3AGYAOABkADcAMQA5ADQAMwBmAGYANQBhADEAYQBjADcANABkADIANgBhADUANwBlADgAMAAyADQANgA1ADIAOQA0AGMAZQA0ADEAMwAzADcANQAyADUANAAzADYAMAA1AGEANgAzADEAMQA5ADAAYwBmADQAZAA2AGQA"

Descriptografa a senha criptografada que foi armazenada no arquivo TSV.

#>
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)))
}
  Os administradores podem adicionar contas de administrador local aos computadores criando um grupo do Active Directory e adicionando-o ao grupo de administradores locais por meio das preferências da Política de Grupo -> Grupo local. Esta ação não armazena em cache as credenciais. A caixa de diálogo é semelhante a seguinte. Esta solução alternativa necessita de uma conexão dos Serviços de Domínio do Active Directory quando o usuário está conectado usando estas credenciais.

Alterações importantes

Ação: Criar, Atualizar ou Substituir

• Os campos Nome de usuário, Senha e Confirmar senha estão desabilitados.

Ação: Excluir

• Nenhuma alteração no comportamento

Soluções alternativas

Em vez de usar o método de senha para a autenticação, você pode usar o Windows Explorer para gerenciar permissões de compartilhamento e alocar direitos aos usuários. Você pode usar os objetos do Active Directory para controlar as permissões para a pasta.

Alterações importantes

Inicialização: Sem alteração, automático ou manual

• Os campos Senha e Confirmar senha estão desabilitados.

• O administrador pode usar contas internas.

Inicialização: Desabilitado

• Nenhuma alteração no comportamento

Caixa de diálogo Novo

• Os administradores que tentam usar usuários não internos para esta conta" recebem o seguinte aviso:

Soluções alternativas

Os Serviços ainda podem ser executados como uma conta de sistema local. As permissões de serviço podem ser alteradas conforme documentado no seguinte artigo da Base de Dados de Conhecimento da Microsoft:

256345 Como definir as configurações da Política de Grupo para definir segurança para serviços do sistema

Observação Se o serviço que deseja configurar não está presente, você deve definir as configurações em um computador que tem o serviço executando. 

Alterações importantes

Ação: Criar, Atualizar ou Substituir

• Quando você seleciona a opção Executar estando o usuário conectado ou não, uma caixa de diálogo não solicita mais as credenciais para administrador.

• A caixa de seleção Não armazenar senha está desabilitada. Por padrão, a caixa também está marcada.

Ação: Excluir

Nenhuma alteração no comportamento

Soluções alternativas

Para as tarefas "Tarefa agendada (pelo menos Windows 7)" e "Tarefa imediata (pelo menos Windows 7)", os administradores podem usar contas de usuário específicas quando determinado usuário está conectado. Ou, eles só podem ter acesso aos recursos locais que aquele usuário. Estas tarefas ainda podem ainda ser executadas no contexto do serviço local.

Alterações importantes

Ação: Criar, Atualizar ou Substituir

• A caixa de seleção Executar como está desabilitada. No entanto, os campos Nome de usuário, Senha e Confirmar senha estão todos desabilitados.

Ação: Excluir

Nenhuma alteração no comportamento

Soluções alternativas

Para os itens "Tarefa agendada" e "Tarefa imediata (Windows XP)" , as tarefas agendadas são executadas usando as permissões que estão atualmente disponíveis para o serviço local.

Alterações importantes

Ação: Criar, Atualizar ou Substituir

• Os campos Nome de usuário, Senha e Confirmar senha estão desabilitados:

Ação: Excluir

• Nenhuma alteração no comportamento

Soluções alternativas

Nenhuma solução alternativa está disponível. Esta preferência não armazena mais credenciais para permitir o acesso a fontes de dados que são protegidas por uma senha.

Detectando preferências do CPassword

Este script deve ser executado a partir de um diretório local do controlador de domínio que você deseja limpar. Copie e salve o conteúdo em um novo arquivo do Windows PowerShell, determine sua unidade do sistema e depois execute o script conforme indicado no seguinte uso.

<#
.SYNOPSIS
Os objetos da Política de Grupo em seu domínio podem ter preferências que armazenam senhas para diferentes tarefas, como a seguinte:
1. Fontes de dados
2. Mapas de unidade
3. Usuários locais
4. Tarefas agendadas (XP e nível superior)
5. Serviços
Estas senhas são armazenadas no SYSVOL como parte das preferências da Política de Grupo e não estão seguras devido a criptografia fraca (AES de 32 bytes).
No entanto, recomendamos que você não implante tais preferências em seu ambiente de domínio e remova qualquer
preferência existente. Esse script é para ajudar o administrador a encontrar as preferências de Política de Grupo no SYSVOL do domínio que contém senhas.

.DESCRIÇÃO
Este script deve ser executado em um DC ou um computador cliente que é instalado com o RSAT para imprimir todas as preferências que contêm
senha com informações como GPO, Nome de preferência, caminho GPEdit sob as quais essa preferência é definida.
Depois de você ter uma lista das preferências afetadas, estas preferências podem ser removidas usando o editor no Console de Gerenciamento da Política de Grupo.

.SINTAXE
Get-SettingsWithCPassword.ps1 [-Path <String>]
.EXEMPLO
Get-SettingsWithCPassword.ps1 -Path %WinDir%\SYSVOL\domain
Get-SettingsWithCPassword.ps1 -Path <Caminho da pasta de Backup de GPO>

.OBSERVAÇÕES
Se o módulo do PS da Política de Grupo não encontrou a saída que conterá os GUIDs do GPO em vez de nomes do GPO. Você pode executar
este script em um controlador de domínio ou executar novamente o script no cliente após instalar o RSAT e
ativar o módulo de Política de Grupo.
Ou, você pode usar os GUIDs do GPO para obter os nomes do GPO usando o cmdlet Get-GPO.

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

#>
#----------------------------------------------------------------------------------------------------------------
# Parâmetros de entrada
#--------------------------------------------------------------------------------------------------------------
param(
[string]$Path = $(throw "-Path is required.") # Caminho do diretório onde estão localizadas as GPPs.
)
#---------------------------------------------------------------------------------------------------------------
$isGPModuleAvailable = $false
$impactedPrefs = { "Groups.xml", "ScheduledTasks.xml","Services.xml", "DataSources.xml", "Drives.xml" }
#----------------------------------------------------------------------------------------------------------------
# importar o módulo da política de grupo, se disponível
#----------------------------------------------------------------------------------------------------------------
if (-not (Get-Module -name "GroupPolicy"))
{
if (Get-Module -ListAvailable |
Where-Object { $_.Name -ieq "GroupPolicy" })
{
$isGPModuleAvailable = $true
Import-Module "GroupPolicy"
}
else
{
Write-Warning "Não é possível importar o módulo da política de grupo para o PowerShell. Portanto, os guids do GPO serão relatados.
Execute este script no DC para obter os nomes do GPO, ou use o cmdlet Get-GPO (no DC) para obter o nome do GPO do guid do GPO."
}
}
else
{
$isGPModuleAvailable = $true
}
Function Enum-SettingsWithCpassword ( [string]$sysvolLocation )
{
# GPMC tree paths
$commonPath = " -> Preferences -> Control Panel Settings -> "
$driveMapPath = " -> Preferences -> Windows Settings -> "

# Obter recursivamente todos os arquivos xml no local SYVOL
$impactedXmls = Get-ChildItem $sysvolLocation -Recurse -Filter "*.xml" | Where-Object { $impactedPrefs -cmatch $_.Name }


# Cada arquivo xml contém várias preferências. Percorrer cada preferência para verificar se ela
# contém o atributo cpassword e exiba-o.
foreach ( $file in $impactedXmls )
{
$fileFullPath = $file.FullName

# Definir a categoria GPP. Se o arquivo está localizado na pasta da máquina em SYSVOL
# a configuração está definida em configuração do computador, caso contrário a
# configuração é uma configuração de usuário
if ( $fileFullPath.Contains("Machine") )
{
$category = "Computer Configuration"
}
elseif ( $fileFullPath.Contains("User") )
{
$category = "User Configuration"
}
else
{
$category = "Unknown"
}
# Obter o conteúdo do arquivo como XML
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
{ # limpar gppWithCpassword e preferenceType para o próximo item.
try
{
Clear-Variable -Name gppWithCpassword -ErrorAction SilentlyContinue
Clear-Variable -Name preferenceType -ErrorAction SilentlyContinue
}
catch [Exception]{}
}
}
if ($gppWithCpassword -ne $null)
{
# Criar o nome do GPO do GUID extraído do Caminho do arquivo
$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
}
}
# exibir preferências que contém o cpassword
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
}
} # finalizar se $gppWithCpassword
} # finalizar foreach $file
} # finalizar funções Enum-PoliciesWithCpassword
#-----------------------------------------------------------------------------------
# Verifique se o caminho é válido. Enumere todas as configurações que contêm o cpassword.
#-----------------------------------------------------------------------------------
if (Test-Path $Path )
{
Enum-SettingsWithCpassword $Path
}
else
{
Write-Warning "Diretório inexistente: $Path"
}


Exemplo de uso (supõe-se que a unidade do sistema é C)

.\Get-SettingsWithCPassword.ps1 –path “C:\Windows\SYSVOL\domain” | Format-List
Observação Esteja ciente de que você também pode direcionar qualquer GPO de backup para o caminho ao invés do domínio.

O script de detecção gera uma lista semelhante à seguinte:



Para as listas maiores, considere a possibilidade de salvar a saída em um arquivo:

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

Removendo as preferências do CPassword

Para remover as preferências que contém os dados do CPassword, sugerimos que você use o Console de Gerenciamento da Política de Grupo (GPMC) no controlador de domínio ou de um cliente que tem as Ferramentas de Administração do Servidor Remoto instaladas. Você pode remover qualquer preferência em cinco etapas nestes consoles. Para fazer isso, execute as seguintes etapas:

1. No GPMC, abra a preferência que contém dados do CPassword.

2. Alterar a ação para Excluir ou Desabilitar, conforme aplicável, para a preferência.

3. Clique em OK para salvar as alterações.

4. Aguarde um ou dois ciclos de atualização da Política de Grupo para permitir que as alterações sejam propagadas para os clientes.

5. Depois que as alterações são aplicadas em todos os clientes, exclua a preferência.

6. Repita as etapas 1 a 5 conforme necessário para limpar o ambiente inteiro. Quando o script de detecção não retorna resultados, você terá concluído.