Windows-Verwaltung

Vereinfachen der Verwaltung von Gruppenrichtlinien mithilfe von Windows PowerShell

Thorbjörn Sjövold

Kurz zusammengefasst:

• Was ist Windows PowerShell?
• So wurden GPOs früher verwaltet
• Migration von Skripts zu Windows PowerShell

Die Technologie von Microsoft für Gruppenrichtlinien wurde nicht von einem Tag auf den anderen angenommen – es war nicht leicht, diese Technologie zu verstehen, und es war erforderlich, sich mit Active Directory zu befassen, einem völlig neuen Dienst, der mit keiner anderen zu dieser Zeit üblichen Konto- und Ressourcendomänen vergleichbar war. Heute sind Gruppenrichtlinien

das Rückgrat der Verwaltung in nahezu jeder Organisation mit einer Windows®-Infrastruktur. Meiner Meinung nach wird genau dasselbe mit Windows PowerShell™ geschehen, der neuesten Verwaltungstechnologie von Microsoft. Windows PowerShell wird Ihre Arbeit als Administrator von Gruppenrichtlinien wahrscheinlich wesentlich erleichtern.

In diesem Artikel wird aufgezeigt, wie Sie die Microsoft®-APIs der Gruppenrichtlinien-Verwaltungskonsole (Group Policy Management Console, GPMC), geschrieben für Windows Skripthost-Sprachen wie VBScript (und COM-basierte Skriptsprachen im Allgemeinen), direkt in Windows PowerShell nutzen können, um die Art und Weise der Verwaltung von Gruppenrichtlinien in Ihrer Umgebung zu vereinfachen.

Aufgaben bei der Skripterstellung für Gruppenrichtlinien

Als Microsoft vor einigen Jahren GPMC veröffentlichte, standen Administratoren für Gruppenrichtlinien plötzlich eine Anzahl überaus praktischer Features zur Verfügung. Insbesondere das auf Gruppenrichtlinien ausgerichtete MMC-Snap-In stellte für das Verwalten von Gruppenrichtlinien einen riesigen Schritt nach vorn dar, besonders für Benutzer und Computer, die mit Active Directory® arbeiteten. Außerdem gab es eine brandneue API, die Administratoren die Nutzung von COM-basierten Sprachen ermöglichte, z. B. VBScript für die Ausführung von Verwaltungsaufgaben für Gruppenrichtlinien, das Erstellen einer Sicherungskopie und das Wiederherstellen von Gruppenrichtlinienobjekten (Group Policy Objects, GPOs), die Migration von GPOs zwischen Domänen, die Konfiguration von Sicherheitseinstellungen in GPOs und Links sowie das Berichtswesen.

Leider bot GPMC nicht die Möglichkeit, die tatsächlich konfigurierten Einstellungen innerhalb der Gruppenrichtlinienobjekte zu bearbeiten. Anders ausgedrückt, es konnten Vorgänge mit dem GPO-Container ausgeführt werden, z. B. Lesen von GPO-Versionen, Lesen von Änderungsdaten, Erstellen brandneuer GPOs, Erstellen von Sicherungskopien von GPOs und Wiederherstellen/Importieren von GPOs aus verschiedenen Domänen usw., der Inhalt des GPOs konnte jedoch programmtechnisch nicht erweitert oder geändert werden, z. B. durch Anlegen eines neuen umgeleiteten Ordners oder Hinzufügen einer neuen Softwareinstallation. Stattdessen wurde im Normalfall das GPO angelegt, alle Einstellungen mithilfe des Gruppenrichtlinienobjekt-Editors manuell konfiguriert, anschließend eine Sicherungskopie des Objekts erstellt und das Objekt schließlich in eine Testumgebung importiert. Nach entsprechenden Funktionstests wurde das Objekt dann in die eigentliche Umgebung importiert. Trotz des fehlenden Features führte die Verwendung von Skripts statt des manuellen Eingriffs mit der GPMC-API zu einer unglaublichen Verringerung in punkto Zeitaufwand und Fehlerhäufigkeit bei den täglichen Verwaltungstätigkeiten für Gruppenrichtlinien.

Die nächste Stufe

Worin unterscheidet sich Windows PowerShell von Skriptsprachen wie VBScript? Zunächst einmal ist Windows PowerShell eine Shell. Für unsere Zwecke können Sie sich eine Shell als Befehlszeileninterpreter vorstellen. VBScript kann zwar von der Befehlszeile ausgeführt, eine VBScript-Datei jedoch nicht Zeile für Zeile abgearbeitet werden. Ein Skript für Windows PowerShell hingegen kann einfach und schnell als eine Folge einzelner Befehle erstellt werden. Außerdem verfügt Windows PowerShell über Funktionen, die fast wie Unterroutinen in VBScript funktionieren und die in Echtzeit mit der Eingabeaufforderung von Windows PowerShell erstellt werden können.

Das Beste ist aber, dass Windows PowerShell auf dem Microsoft .NET Framework basiert, im Gegensatz zu VBScript, das auf der älteren COM-Technologie beruht. Die riesigen Mengen an .NET-Code, die heute geschrieben werden, können demzufolge direkt aus Windows PowerShell heraus genutzt werden.

Im Prinzip erhalten Sie daher mit Windows PowerShell volle Unterstützung für Skripting und einen interaktiven Modus in einem einzigen Paket. Die hier vorgestellten Beispiele sind allesamt Befehlszeileneingaben, die Sie gleich während des Lesens eingeben können. Die Beispiele funktionieren jedoch gleichermaßen gut, wenn Sie sie in eine Skriptdatei für Windows PowerShell schreiben und die Datei ausführen.

Umstellen von älteren Skripts auf Windows PowerShell

Es steht außer Frage, dass Sie beim Umstieg auf eine neue Technologie die bereits geleistete Arbeit nicht einfach wegwerfen wollen. Es gibt drei Ansätze, mit denen Sie von der GPMC-API auf COM-Objekte zugreifen oder grundsätzlich jedes beliebige von früher vorhandene VBScript wiederverwenden können. Wählen Sie eine dieser Methoden aus:

• Erstellen eines Cmdlets für Windows PowerShell mithilfe einer Programmiersprache wie C# oder verwaltetem C++.
• Zugriff auf ScriptControl in MSScript.ocx mithilfe von Windows PowerShell, um ältere Skripts einzubinden.
• Einbinden von COM-Aufrufen in wiederverwendbare Funktionen von Windows PowerShell bzw. direktes Aufrufen der COM-Objekte.

An dieser Stelle wird hauptsächlich die dritte Option erörtert, aber zunächst wird ein kurzer Blick auf die anderen Optionen geworfen.

Erstellen eines Cmdlets für Windows PowerShell

Microsoft hat eine große Anzahl von Cmdlets in Windows PowerShell integriert, mit denen Sie Dateien kopieren, Ausgaben formatieren, Datum und Uhrzeit abrufen können uvm. Es ist aber auch möglich, eigene Cmdlets zu erstellen. Der Vorgang ist unter msdn2.microsoft.com/ms714598.aspx ausführlich dokumentiert. Im Folgenden sind die Schritte kurz zusammengefasst:

• Erstellen Sie in einer .NET-Programmiersprache wie C# eine Klassenbibliothek-DLL.
• Erstellen Sie eine neue Klasse, die vom Basisklassen-Cmdlet erbt.
• Legen Sie Attribute fest, mit denen Name, Verwendung, Eingabeparameter usw. bestimmt werden, und fügen Sie Ihren Code hinzu.

Da Windows PowerShell auf dem .NET Framework aufgebaut ist, sind alle Typen wie Zeichenfolgen, Objekte usw., die als Parameter zurückgegeben oder übergeben werden, genau im gleichen Code wie Windows PowerShell. Es ist daher keine gesonderte Typkonvertierung erforderlich.

Die wirkliche Stärke dieser Lösung besteht darin, dass Sie eine vollständige Programmiersprache zur Verfügung haben.

Einbinden älterer Skripts mithilfe des ScriptControl-Objekts in MSScript.ocx

Natürlich benötigen Sie das VBScript-Modul, um eine VBScript-Datei ausführen zu können. Nicht so offensichtlich ist, dass es sich bei diesem Modul um ein COM-Objekt handelt. Da Sie COM-Objekte in Windows PowerShell verwenden können, ist es möglich, dieses VBScript-Modul aufzurufen. Dies könnte etwa so vor sich gehen:

$scriptControl = New-Object -ComObject ScriptControl
$scriptControl.Language = ‘VBScript’
$scriptControl.AddCode(
    ‘Function ShowMessage(messageToDisplay)
    MsgBox messageToDisplay
    End Function’)
$scriptControl.ExecuteStatement(‘ShowMessage
    “Hello World”’)

Wenn Sie diesen Code in die Befehlszeilenschnittstelle (Command Line Interface, CLI) der Windows PowerShell eingeben, wird die VBScript-Funktion „ShowMessage“ aufgerufen und mit einem Parameter ausgeführt, wodurch ein Meldungsfeld mit dem Text „Hello World“ angezeigt wird.

Einige Leser denken jetzt vielleicht: „Na prima! Ich beherrsche nun die Kunst der Verwendung von COM in WindowsPowerShell. Jetzt kann ich diesen Artikel beiseite legen und damit beginnen, das Objekt „ScriptControl“ mit meiner Sammlung von alten GPMC-Skripts aufzufüllen. Leider ist dies nicht der Fall. Dieses Verfahren wird schnell sehr komplex und schwierig zu debuggen, sobald die Skripts größer werden.

Einbinden von COM-Objekten

Die beste Option ist daher die dritte: das Einbinden der COM-Aufrufe in wiederverwendbare Funktionen von Windows PowerShell, wodurch die COM-Objekte in der GPMC-API verwendet werden können. Die Zeile unten zeigt an, wie ein .NET-Objekt direkt in Windows PowerShell erstellt wird. In diesem Fall handelt es sich um ein „FileInfo“-Objekt, mit dem die Größe der Datei abgerufen werden kann:

$netObject = New-Object System.IO.FileInfo(
“C:\boot.ini”) # Create an instance of FileInfo 
               # representing c:\boot.ini

Beachten Sie, dass in Windows PowerShell das Zeichen # für Kommentare in Programmzeilen verwendet wird. Mithilfe des neu instanziierten „FileInfo“-Objekts können Sie durch Eingabe des folgenden Codes auf einfache Weise die Größe von „boot.ini“ abrufen:

$netObject.Length # Display the size in bytes of the
                  # file in the command line interface

Aber halt! Wollten wir nicht über COM-Objekte und VBScript-Konvertierung sprechen? Ja, aber schauen Sie sich den folgenden Befehl an:

$comFileSystemObject = New-Object –ComObject Scripting.FileSystemObject

Sie werden bemerken, dass die Syntax im Grunde identisch mit der Syntax ist, die zum Anlegen nativer Objekte aus .NET Framework verwendet wurde, jedoch mit zwei Unterschieden. Erstens wurde der Schalter –ComObject eingefügt, wodurch Windows PowerShell auf die COM-Welt anstatt auf die .NET-Welt ausgerichtet wird. Zweitens wird eine COM-ProgID anstatt eines .NET-Konstruktors verwendet, in diesem Fall „Scripting.FileSystemObject“. Die ProgID ist der gleiche Name, den Sie schon immer verwendet haben. In VBScript sähe der äquivalente Code so aus:

Set comFileSystemObject = CreateObject(
    “Scripting.FileSystemObject”)

Um die Dateigröße mithilfe von VBScript abzurufen, fügen Sie die oben angegebene Zeile zusammen mit dem folgenden Code in eine Datei ein:

Set comFileObject = comFileSystemObject.GetFile(
    “C:\Boot.ini”)
WScript.Echo comFileObject.Size

Führen Sie die Datei anschließend aus, z. B. mit Cscript.exe. In Windows PowerShell ginge das so vor sich (direkt von der Befehlszeile von Windows PowerShell aus):

$comFileObject = $comFileSystemObject.GetFile(
    “C:\boot.ini”)
$comFileObject.Size

Selbstverständlich hätte ein VBScript, das die Größe einer Datei ausliest, auch mithilfe des Windows PowerShell-Cmdlet zum Verwalten von Laufwerksobjekten konvertiert werden können. Hier sollte jedoch aufgezeigt werden, wie einfach der Zugriff auf COM aus Windows PowerShell ist. Obwohl ich Windows PowerShell angewiesen habe, ein COM-Objekt zu erstellen, wurde in diesem Fall in Wirklichkeit ein $comFileSystemObject erstellt, ein .NET-Objekt, dass das COM-Objekt einbindet und die Schnittstelle des COM-Objekts nach außen zur Verfügung stellt. Im Rahmen dieses Artikels spielt dies aber keine Rolle.

Windows PowerShell in Aktion

Sie wissen nun, wie von Windows PowerShell auf COM zugegriffen wird. Jetzt werden die Gruppenrichtlinien näher beleuchtet. Die hier aufgeführten Beispiele zeigen kurze Codeausschnitte, die eine Vorstellung darüber geben, wie die GPMC-APIs von Windows PowerShell zu verwenden sind. Einen vollständigen Satz an Windows PowerShell-Funktionen für das Verwalten von Gruppenrichtlinien im Codedownload zu diesem Artikel finden Sie online unter technetmagazine.com/code07.aspx. Abbildung 1 listet die im Download enthaltenen Funktionen auf.

Figure 1 Benutzerdefinierte Funktionen im Download

Beim Lesen dieses Abschnitts können Sie ruhig die Befehlszeile von Windows PowerShell aufrufen und die Befehle eingeben. Beachten Sie jedoch, dass einige Befehle von zuvor ausgeführten Befehlen abhängig sind. Anders gesagt, einige der zu Anfang erstellten Objekte werden später verwendet. Schließen Sie daher die Windows PowerShell-Sitzung nicht. Wenn Sie die Sitzung schließen, müssen Sie wieder von vorn anfangen und sämtliche Befehle nochmals eingeben.

Aufgabe ist es, mithilfe von Windows PowerShell ein neues GPO zu erstellen. Das Entwicklerteam für Gruppenrichtlinien bei Microsoft hat der GPMC eine Anzahl von voll funktionsfähigen VBScript-Beispielen beigefügt, mit denen Sie Ihre Entwicklungsarbeiten beschleunigen können. Die Beispiele befinden sich im Verzeichnis „%ProgramFiles%\GPMC\Scripts“. In diesem Verzeichnis befindet sich außerdem eine Datei mit dem Namen „gpmc.chm“, in der die Dokumentation zur GPMC-API enthalten ist. Sehen Sie sich das Skript „CreateGPO.wsf“ näher an, um zu sehen, wie es funktioniert.

Ziemlich am Anfang sehen Sie diese Zeile:

Dim GPM
Set GPM = CreateObject(“GPMgmt.GPM”)

Dies ist im Grunde der Ausgangspunkt jeder Sitzung oder jedes Skripts für das Verwalten von Gruppenrichtlinien, da hier die Klasse „GPMgmt.GPM“ instanziiert wird, die den Zugriff auf fast alle GPMC-Funktionen ermöglicht. Dies soll nun stattdessen in Windows PowerShell ausgeführt werden:

$gpm = New-Object -ComObject GPMgmt.GPM

Sie verfügen jetzt über den Ausgangspunkt für das Verwalten von Gruppenrichtlinien. Im nächsten Schritt müssen Sie herausfinden, wozu dies nützlich ist. Normalerweise finden Sie diese Art von Informationen in der Dokumentation. Windows PowerShell verfügt aber über ein wirklich cooles Feature. Wenn Sie die folgende Zeile eingeben, erhalten Sie die in Abbildung 2 dargestellte Ausgabe:

Abbildung 2** Ausgabe von Get-Member **(Klicken Sie zum Vergrößern auf das Bild)

$gpm | gm

Ziemlich cool, wenn Sie mich fragen. Beachten Sie, wie Sie mit dem Cmdlet „Get-Member“ (oder „gm“) die vom Objekt unterstützten Eigenschaften und Methoden direkt von der Befehlszeile aus anzeigen können. Selbstverständlich ist dies nicht mit dem Studieren der Dokumentation gleichzusetzen, aber es vereinfacht die Verwendung von Objekten, mit denen Sie bereits vertraut sind, falls Sie sich nicht an die genaue Anzahl der Parameter, den genauen Namen usw. erinnern können. Anzumerken ist, dass die Knotenlisten in der GPMC-Dokumentation wie das GPM-Objekt aussehen und alle anderen Klassen das Präfix „I“ tragen. Dies liegt an der internen Abwicklung von COM und ist hier nicht weiter wichtig. Es ist für C++-Programmierer gedacht, die nativen COM-Code schreiben, und kennzeichnet den Unterschied zwischen einer Schnittstelle und der Klasse, die diese Schnittstelle implementiert. Beachten Sie außerdem, dass es bei Verwendung der GPMC-APIs nur ein einziges Objekt gibt, das auf diese Weise erstellt werden muss, nämlich „GPMgmt.GPM“. Alle anderen Objekte werden mithilfe von Methoden erstellt, die von diesem GPM-Objekt ausgehen.

Das Erstellen des neuen GPO wird nun fortgesetzt.

Abbildung 3 zeigt, wie einfach ein GPO erstellt werden kann. Beachten Sie, dass einiges an Code, einschließlich Fehlerbehandlung (z. B. was geschehen soll, wenn Sie nicht zum Erstellen von GPOs berechtigt sind) weggelassen und ein Domänennamen hartcodiert wurde, aber das Prinzip stimmt.

Figure 3 Erstellen eines GPOs

$gpmConstants = $gpm.GetConstants() 
# This is the GPMC way to retrieve all 
# constants
$gpmDomain =$gpm.GetDomain(“Mydomain.local”, “”, $gpmConstants.UseAnyDC)
# Connects to the domain where the GPO should 
# be created, replace Mydomain.local with the 
# name of the domain to connect to.
$gpmNewGpo = $gpmDomain.CreateGPO() 
# Create the GPO
$gpmNewGpo.DisplayName = “My New Windows PowerShell GPO” 
# Set the name of the GPO

Jetzt wissen Sie, wie ein GPO erstellt wird. Als Nächstes soll ein bereits vorhandenes GPO geöffnet werden. Sie verfügen immer noch über den Verweis zur Domäne, $gpmDomain. Geben Sie also Folgendes ein:

$gpmExistingGpo = $gpmDomain.GetGPO(
  “{31B2F340-016D-11D2-945F-00C04FB984F9}”) 
# Open an existing GPO based on its GUID, 
# in this case the Default Domain Policy.
$gpmExistingGpo.DisplayName 
# Show the display name of the GPO, it 
# should say Default Domain Policy
$gpmExistingGpo.GenerateReportToFile($gpmConstants.ReportHTML, “.\DefaultDomainPolicyReport.html”

Dadurch erhalten Sie einen vollständigen HTML-Bericht mit den Einstellungen in der Standarddomänenrichtlinie, aber Sie können natürlich jede dieser Methoden und Eigenschaften verwenden (z. B. „ModificationTime“, die Informationen zur Zeit der letzten Änderung enthält), um in Erfahrung zu bringen, wann eine der Einstellungen im GPO geändert wurde.

Dies ist äußerst nützlich. Sie waren bestimmt schon einmal in einer Situation, in der das Telefon wie verrückt klingelt und sich Benutzer darüber beschweren, dass sich ihre Computer merkwürdig benehmen. Sie gehen davon aus, dass dies mit einer geänderten, hinzugefügten oder gelöschten GPO-Einstellung zu tun hat, aber Sie haben keine Ahnung, welches GPO Sie überprüfen sollen. Windows PowerShell kommt Ihnen zu Hilfe! Wenn Sie das in Abbildung 4 dargestellte Skript in die Befehlszeile von Windows PowerShell eingeben, erhalten Sie alle GPOs, die in den vergangenen 24 Stunden geändert wurden.

Figure 4 Erkennen geänderter GPOs

$gpmSearchCriteria = $gpm.CreateSearchCriteria() 
# We want all GPOs so no search criteria will be specified
$gpmAllGpos = $gpmDomain.SearchGPOs($gpmSearchCriteria) 
# Find all GPOs in the domain
foreach ($gpmGpo in $gpmAllGpos)
{
if ($gpmGpo.ModificationTime -ge (get-date).AddDays(-1)) {$gpmGpo.DisplayName}
# Check if the GPO has been modified less than 24 hours from now 
}

Beachten Sie den Operator „–ge“, der für „größer oder gleich“ steht. Das sieht vielleicht ein wenig seltsam aus, wenn Sie an die Operatoren < und > aus anderen Skript- oder Programmiersprachen gewöhnt sind. Diese Operatoren werden jedoch für Umleitungen verwendet, z. B. für die Umleitung der Ausgabe in eine Datei, und können folglich in Windows PowerShell nicht als Vergleichsoperatoren genutzt werden.

Zusammenfassung

Im Code in Abbildung 5 wird das vollständige Skript zum Kopieren der Einstellungen aus einem GPO in ein anderes GPO aufgelistet. Sie sollten jetzt eine solide Vorstellung davon haben, wie die neue Technologie mit Gruppenrichtlinien verwendet werden kann und wie beliebige COM-Objekte oder VBScript-Codes, die ein COM-Objekt nutzen, wiederverwendet werden können.

Figure 5 Kopieren der Einstellungen aus einem GPO in ein anderes GPO

###########################################################################
# Function  : CopyGpo
# Description: Copies the settings in a GPO to another GPO
# Parameters : $sourceGpo     - The GPO name or GPO ID of the GPO to copy
#           : $sourceDomain   - The dns name, such as microsoft.com, of the domain where the original GPO is located
#           : $targetGpo      - The GPO name of the GPO to add
#           : $targetDomain   - The dns name, such as microsoft.com, of the domain where the copy should be put
#           : $migrationTable - The path to an optional Migration table to use when copying the GPO
# Returns   : N/A
# Dependencies: Uses GetGpoByNameOrID, found in article download
###########################################################################
function CopyGpo(
 [string] $sourceGpo=$(throw ‘$sourceGpo is required’),
 [string] $sourceDomain=$(throw ‘$sourceDomain is required’),
 [string] $targetGpo=$(throw ‘$targetGpo is required’),
 [string] $targetDomain=$(throw ‘$targetDomain is required’),
 [string] $migrationTable=$(“”),
 [switch] $copyAcl)
{
 
 $gpm = New-Object -ComObject GPMgmt.GPM # Create the GPMC Main object
 $gpmConstants = $gpm.GetConstants() # Load the GPMC constants
 $gpmSourceDomain = $gpm.GetDomain($sourceDomain, “”, $gpmConstants.UseAnyDC) # Connect to the domain passed 
                                                                              # using any DC
 $gpmSourceGpo = GetGpoByNameOrID $sourceGpo $gpmSourceDomain
 # Handle situations where no or multiple GPOs was found
 switch ($gpmSourceGpo.Count)
 {
   {$_ -eq 0} {throw ‘No GPO named $gpoName found’; return}
   {$_ -gt 1} {throw ‘More than one GPO named $gpoName found’; return} 
 }
 if ($migrationTable)
 {
   $gpmMigrationTable = $gpm.GetMigrationTable($migrationTable)
 }

 $gpmTargetDomain = $gpm.GetDomain($targetDomain, “”, $gpmConstants.UseAnyDC) # Connect to the domain passed 
                                                                              # using any DC

 $copyFlags = 0
 if ($copyAcl)
 {
   $copyFlags = Constants.ProcessSecurity
 }
 $gpmResult = $gpmSourceGpo.CopyTo($copyFlags, $gpmTargetDomain, $targetGpo)
 [void] $gpmResult.OverallStatus
 
}

Genau wie die Gruppenrichtlinien wird sich Windows PowerShell zu einem natürlichen Bestandteil aller Windows-Verwaltungsumgebungen entwickeln. Aber es gibt zunächst Millionen Zeilen an VBScript, die migriert und verwaltet werden müssen, und dieses Lernprogramm wird Ihnen hoffentlich dabei helfen.

Es gibt eine Anzahl von Quellen, mit denen Sie die Verwaltung von Gruppenrichtlinien und andere Aufgabengebiete erweitern können, in denen Sie bisher VBScript genutzt haben. Dazu gehören die Windows PowerShell-Funktionen im Download und ein hervorragendes Handbuch für die Konvertierung von VBScript zu Windows PowerShell auf der TechNet-Website. In diesem Handbuch finden Sie Hinweise zum Ausführen häufiger Aufgaben in Windows PowerShell, wenn Ihnen das entsprechende Vorgehen in VBScript vertraut ist. Sie finden das Handbuch unter microsoft.com/technet/scriptcenter/topics/winpsh/convert.

Außerdem gibt es eine vollständige Dokumentation der GPMC-API. Sie können diese Informationen von der Gruppenrichtlinien-Website unter microsoft.com/grouppolicy herunterladen.

Fazit: Falls Sie Windows PowerShell noch nicht installiert haben, worauf warten Sie noch? Laden Sie die Windows PowerShell von microsoft.com/powershell herunter. Viel Spaß!

Thorbjörn Sjövold ist CTO und Gründer von Special Operations Software (www.specopssoft.com), ein Anbieter von Erweiterungsprodukten für auf Gruppenrichtlinien basierende Systemverwaltung und Systemsicherheit. Sie können Thorbjörn Sjövold unter thorbjorn.sjovold@specopssoft.com erreichen.

© 2008 Microsoft Corporation und CMP Media, LLC. Alle Rechte vorbehalten. Die nicht genehmigte teilweise oder vollständige Vervielfältigung ist nicht zulässig.