Welche Berechtigungen / Rechte benötigt ein Benutzer, um auf Remotecomputern WMI-Zugriff zu erhalten?

Ich schreibe einen Überwachungsdienst, der WMI verwendet, um Informationen von Remotecomputern abzurufen. Aus politischen Gründen ist es nicht möglich, lokale Administratorrechte für alle diese Computer zu haben.

Ist das möglich? Welche Berechtigungen / Rechte benötigt mein Benutzer dafür?

Das Folgende funktioniert unter Windows 2003 R2 SP 2, Windows Server 2012 R2

1. Fügen Sie die betreffenden Benutzer der Gruppe " Systemmonitorbenutzer " hinzu
2. Rufen Sie unter Dienste und Anwendungen das Eigenschaftsdialogfeld von WMI Control auf (oder führen Sie es aus wmimgmt.msc). Markieren Sie auf der Registerkarte Sicherheit die Option Root/CIMV2Sicherheit. Fügen Sie Systemmonitorbenutzer hinzu, und aktivieren Sie die Optionen: Enable AccountundRemote Enable
3. Rennen dcomcnfg. Klicken Sie unter Komponentendienste> Computer> Arbeitsplatz im Dialogfeld Eigenschaften auf der Registerkarte COM-Sicherheit für Access Permissionsund auf "Grenzwerte bearbeiten" Launch and Activation Permissions. Fügen Sie Systemmonitorbenutzer hinzu, und ermöglichen Sie Remotezugriff, Remotestart und Remoteaktivierung.
4. Wählen Sie Windows Management Instrumentation unter Komponentendienste> Computer> Arbeitsplatz> DCOM - Konfiguration und geben Remote Launchund Remote ActivationPrivilegien Performance Monitor Users Group.

Anmerkungen:

• Alternativ zu Schritt 3 und 4 kann der Benutzer der Gruppe Distributed COM Users (Getestet unter Windows Server 2012 R2) zugewiesen werden.
• Wenn der Benutzer Zugriff auf alle Namespaces benötigt, können Sie die Einstellungen in 2. auf der RootEbene festlegen und die Berechtigungen für die Subnamespaces über das AdvancedFenster in wiederherstellenSecurity

Alles, was ich unter Windows 8 getan habe, war, Benutzer zur Gruppe "Remote Management Users" hinzuzufügen, und Remote-WQL-Anforderungen funktionierten.

Standardmäßig verfügt nur die lokale Administratorgruppe über Remoteberechtigungen für WMI. Sie müssen die WMI-Berechtigungen "Remote Enable" anpassen.

Möglicherweise müssen Sie auch "DCOM-Remotezugriffsberechtigungen" und / oder "DCOM-Remotestart- und Aktivierungsberechtigungen" erteilen, je nachdem, was genau Sie tun möchten. Dieser MSDN-Artikel enthält schrittweise Anleitungen.

Das Folgende funktionierte für mich in einer 2012 r2-Domänenumgebung, obwohl ich es nur pro Server und nicht für die gesamte Domäne geschafft habe:

1) Fügen Sie einen Benutzer zur Leistungsprotokollbenutzergruppe hinzu. 2) Führen Sie wmimgmt.msc aus, klicken Sie mit der rechten Maustaste auf "WMI Control (LOCAL)", wechseln Sie zur Registerkarte "Sicherheit" und erteilen Sie dem entsprechenden Benutzer "Enable Account" und "Remote Enable" für den gewünschten Namespace (normalerweise CIMV2).

Wenn ich es schaffe, es für die gesamte Domain zu erledigen, komme ich zurück und aktualisiere.

Basierend auf der gewählten Antwort habe ich das Skript von Microsoft geändert, um die WMI-Sicherheit festzulegen. Mein Testbenutzer war ein nicht administrativer Domänenbenutzer, der aus Gründen, die nicht mit diesem Problem zusammenhängen, Mitglied der "Remoteverwaltungsbenutzer" auf dem lokalen System war . Nachdem ich meinem Benutzer die Berechtigungen EnableAccount, RemoteEnable und ExecuteMethods für den Zielnamespace erteilt hatte, konnte ich auf WMI zugreifen.

Also, ich habe nicht hinzufügen , meine Benutzer den Performance Monitor Benutzer oder Distributed COM - Benutzer lokale Gruppen.

Ein paar Anmerkungen zum Drehbuch:

1. Sie müssen den vollständigen Pfad des Namespaces angeben. In meinem Fall war der Namespace Root / Microsoft / SqlServer
2. Vererbung war falsch. Da es keine Blattobjekte gibt, die Sie nicht verwenden können$OBJECT_INHERIT_ACE_FLAG
3. Ich habe die eingebettete Funktion entfernt, weil sie zu klein war und nur einmal verwendet wurde.

Das Skript ist unten. Ich habe es Set-WMINamespaceSsecurity.ps1 genannt

Param ([Parameter(Mandatory=$true,Position=0)] [string]$Namespace,
       [Parameter(Mandatory=$true,Position=1)] [ValidateSet("Add","Remove")] [string]$Operation,
       [Parameter(Mandatory=$true,Position=2)] [string] $Account,
       [Parameter(Mandatory=$false,Position=3)] [ValidateSet("EnableAccount","ExecuteMethods","FullWrite","PartialWrite","ProviderWrite","RemoteEnable","ReadSecurity","WriteSecurity")] [string[]] $Permissions=$null,
       [Parameter(Mandatory=$false)] [switch]$AllowInherit,
       [Parameter(Mandatory=$false)] [switch]$Deny,
       [Parameter(Mandatory=$false)] [string]$ComputerName=".",
       [Parameter(Mandatory=$false)] [System.Management.Automation.PSCredential]$Credential=$null)

$OBJECT_INHERIT_ACE_FLAG    = 0x1
$CONTAINER_INHERIT_ACE_FLAG = 0x2
$ACCESS_ALLOWED_ACE_TYPE    = 0x0
$ACCESS_DENIED_ACE_TYPE     = 0x1

$WBEM_ENABLE            = 0x01
$WBEM_METHOD_EXECUTE    = 0x02
$WBEM_FULL_WRITE_REP    = 0x04
$WBEM_PARTIAL_WRITE_REP = 0x08
$WBEM_WRITE_PROVIDER    = 0x10
$WBEM_REMOTE_ACCESS     = 0x20
$WBEM_RIGHT_SUBSCRIBE   = 0x40
$WBEM_RIGHT_PUBLISH     = 0x80
$READ_CONTROL           = 0x20000
$WRITE_DAC              = 0x40000
$WBEM_S_SUBJECT_TO_SDS  = 0x43003

$ErrorActionPreference = "Stop"

$InvokeParams=@{Namespace=$Namespace;Path="__systemsecurity=@";ComputerName=$ComputerName}
if ($PSBoundParameters.ContainsKey("Credential")) { $InvokeParams+= @{Credential=$Credential}}

$output = Invoke-WmiMethod @InvokeParams -Name "GetSecurityDescriptor"
if ($output.ReturnValue -ne 0) { throw "GetSecurityDescriptor failed:  $($output.ReturnValue)" }

$ACL = $output.Descriptor

if ($Account.Contains('\')) {
  $Domain=$Account.Split('\')[0]
  if (($Domain -eq ".") -or ($Domain -eq "BUILTIN")) { $Domain = $ComputerName }
  $AccountName=$Account.Split('\')[1]
}
elseif ($Account.Contains('@')) {
  $Somain=$Account.Split('@')[1].Split('.')[0]
  $AccountName=$Account.Split('@')[0]
}
else {
  $Domain = $ComputerName
  $AccountName = $Account
}

$GetParams = @{Class="Win32_Account" ;Filter="Domain='$Domain' and Name='$AccountName'"}
$Win32Account = Get-WmiObject @GetParams
if ($Win32Account -eq $null) { throw "Account was not found: $Account" }

# Add Operation
if ($Operation -eq "Add") {
  if ($Permissions -eq $null) { throw "Permissions must be specified for an add operation" }

  # Construct AccessMask
  $AccessMask=0
  $WBEM_RIGHTS_FLAGS=$WBEM_ENABLE,$WBEM_METHOD_EXECUTE,$WBEM_FULL_WRITE_REP,$WBEM_PARTIAL_WRITE_REP,$WBEM_WRITE_PROVIDER,$WBEM_REMOTE_ACCESS,$READ_CONTROL,$WRITE_DAC
  $WBEM_RIGHTS_STRINGS="EnableAccount","ExecuteMethods","FullWrite","PartialWrite","ProviderWrite","RemoteEnable","ReadSecurity","WriteSecurity"
  $PermissionTable=@{}
  for ($i=0; $i -lt $WBEM_RIGHTS_FLAGS.Count; $i++) { $PermissionTable.Add($WBEM_RIGHTS_STRINGS[$i].ToLower(), $WBEM_RIGHTS_FLAGS[$i]) }
  foreach ($Permission in $Permissions) { $AccessMask+=$PermissionTable[$Permission.ToLower()] }

  $ACE=(New-Object System.Management.ManagementClass("Win32_Ace")).CreateInstance()
  $ACE.AccessMask=$AccessMask
  # Do not use $OBJECT_INHERIT_ACE_FLAG.  There are no leaf objects here.
  if ($AllowInherit.IsPresent) { $ACE.AceFlags=$CONTAINER_INHERIT_ACE_FLAG }
  else { $ACE.AceFlags=0 }

  $Trustee=(New-Object System.Management.ManagementClass("Win32_Trustee")).CreateInstance()
  $Trustee.SidString = $Win32Account.SID
  $ACE.Trustee=$Trustee

  if ($Deny.IsPresent) { $ACE.AceType = $ACCESS_DENIED_ACE_TYPE } else { $ACE.AceType = $ACCESS_ALLOWED_ACE_TYPE }
  $ACL.DACL+=$ACE
}
#Remove Operation
else {
  if ($Permissions -ne $null) { Write-Warning "Permissions are ignored for a remove operation" }
  [System.Management.ManagementBaseObject[]]$newDACL = @()
  foreach ($ACE in $ACL.DACL) {
    if ($ACE.Trustee.SidString -ne $Win32Account.SID) { $newDACL+=$ACE }
  }
  $ACL.DACL = $newDACL
}

$SetParams=@{Name="SetSecurityDescriptor"; ArgumentList=$ACL}+$InvokeParams

$output = Invoke-WmiMethod @SetParams
if ($output.ReturnValue -ne 0) { throw "SetSecurityDescriptor failed: $($output.ReturnValue)" }

Wir haben dies für PRTG getan: Wir haben einen neuen Domänenbenutzer erstellt: Ein Gruppenrichtlinienobjekt erstellt, um seinen Benutzer in die Gruppe "Protokollbenutzer ausführen" zu stellen, und ein Powershell-Skript verwendet, um diesen Benutzer zu WMI Control hinzuzufügen. Dank an:

https://live.paloaltonetworks.com/t5/Management-Articles/PowerShell-Script-for-setting-WMI-Permissions-for-User-ID/ta-p/53646