Kategorien
Scripte

Service Packs und Fixes mit PowerShell

Powershell Logo

Einführung

Ein wichtiger Bestandteil der Aktualisierung von Betriebssystemen und Anwendungen sind Service Packs und Hotfixes. Mit PowerShell, Microsofts mächtiger Skriptsprache und Kommandozeileninterpreter, kannst du Informationen über installierte Service Packs abrufen. Hier ein Beispiel, wie das geht.

Du kannst das WMI-Objekt (Windows Management Instrumentation) verwenden, um diese Informationen abzurufen.

Hier ist ein Beispiel, wie du die installierten Service Packs mit PowerShell abrufen kannst.

# Verwende das WMI-Objekt, um Informationen zu den installierten Service Packs abzurufen
$servicePacks = Get-WmiObject -Class Win32_OperatingSystem | Select-Object -ExpandProperty ServicePackMajorVersion

# Gib die installierten Service Packs aus
Write-Host "Installierte Service Packs:"
$servicePacks | ForEach-Object { Write-Host "- $_" }

Danach folgt hier ein Beispiel, wie du die installierten Hotfixes abrufen kannst.

# Verwende das WMI-Objekt, um Informationen zu den installierten Hotfixes abzurufen
$hotfixes = Get-WmiObject -Class Win32_QuickFixEngineering | Select-Object -Property HotFixID

# Gib die installierten Hotfixes aus
Write-Host "Installierte Hotfixes:"
$hotfixes | ForEach-Object { Write-Host "- $_.HotFixID" }

Anschließend wird der Code kombiniert und ergibt das nachfolgende Script.

# Service Packs abrufen
$servicePacks = Get-WmiObject -Class Win32_OperatingSystem | Select-Object -ExpandProperty ServicePackMajorVersion

if ($servicePacks) {
    Write-Host "Installierte Service Packs:"
    foreach ($sp in $servicePacks) {
        Write-Host "Service Pack $sp"
    }
}
else {
    Write-Host "Es sind keine Service Packs installiert."
}

# Hotfixes abrufen
$hotfixes = Get-WmiObject -Class Win32_QuickFixEngineering

if ($hotfixes) {
    Write-Host "Installierte Hotfixes:"
    foreach ($hotfix in $hotfixes) {
        $hotfixId = $hotfix.HotFixID
        $description = $hotfix.Description
        Write-Host "Hotfix ID: $hotfixId"
        Write-Host "Beschreibung: $description"
        Write-Host "-----"
    }
}
else {
    Write-Host "Es sind keine Hotfixes installiert."
}

Die WMI Klassen

Diese Beispiele verwenden die WMI-Klassen Win32_OperatingSystem und Win32_QuickFixEngineering, um die benötigten Informationen abzurufen. Die Ausgabe zeigt die installierten Service Packs bzw. Hotfixes an.

Die WMI-Klasse Win32_OperatingSystem ist eine Klasse in der Windows Management Instrumentation (WMI), die Informationen über das Betriebssystem eines Computersystems bereitstellt. Diese Klasse enthält eine Vielzahl von Eigenschaften und Methoden, mit denen man verschiedene Aspekte des Betriebssystems abfragen kann.

Die Win32_QuickFixEngineering-Klasse ist eine WMI-Klasse (Windows Management Instrumentation) in Windows-Betriebssystemen, die Informationen über installierte Windows-Sicherheitsupdates, Hotfixes und Service Packs enthält. Sie ermöglicht den Zugriff auf Informationen über Patches und Updates, die auf einem Windows-System installiert wurden, um bekannte Probleme, Sicherheitslücken oder Fehler zu beheben. Die Klasse enthält verschiedene Eigenschaften, die Details zu den installierten Updates liefern. Dazu gehören der Name des Updates, die Beschreibung, das Installationsdatum und der Status (installiert, deinstalliert usw.).

Bitte beachte, dass du administrative Rechte benötigst, um auf diese Informationen zuzugreifen.

Kategorien
Scripte

Active Directory null Streß mit Scripten

DB Icon Graustufen

Einführung

Active Directory ist eine zentrale Komponente in vielen IT-Infrastrukturen und wird häufig zur Verwaltung von Benutzern, Gruppen, Computern und anderen Ressourcen verwendet. Die Verwaltung von Active Directory kann jedoch zeitaufwändig und fehleranfällig sein, insbesondere in großen Netzwerken mit vielen Benutzern und Ressourcen.

Eine Möglichkeit, die Verwaltung von Active Directory zu automatisieren und zu vereinfachen, ist die Verwendung von Skripten. Hier sind einige Beispiele, wie Skripte verwendet werden können, um Active Directory-Aufgaben zu automatisieren:

Lebenszyklus von Benutzerkonten automatisieren

Das automatische Erstellen neuer Benutzerkonten oder das Ändern oder Löschen bestehender Benutzerkonten ist normalerweise die erste Aufgabe, die in Angriff genommen wird. Diese Skripte können auch E-Mail-Adressen, Gruppenmitgliedschaften und andere Eigenschaften automatisch verwalten.

Gruppenrichtlinien automatisieren

Skripte können erstellt werden, um Gruppenrichtlinien automatisch auf bestimmte Gruppen von Computern oder Benutzern anzuwenden. Diese Skripte können auch verwendet werden, um sicherzustellen, dass Gruppenrichtlinien auf dem neuesten Stand sind und dass Änderungen automatisch auf alle betroffenen Benutzer in einer Domäne angewendet werden.

Automatisierung der Sicherheitsgruppen

Skripte können auch erstellt werden, um Sicherheitsgruppen automatisch zu erstellen oder zu ändern, um den Zugriff auf Ressourcen im Active Directory zu steuern. Diese Skripte können auch verwendet werden, um sicherzustellen, dass die Mitgliedschaft in Sicherheitsgruppen korrekt und aktuell ist.

Die Automatisierung von Berichten

Skripte können erstellt werden, um automatisch Berichte über die Aktivitäten im Active Directory zu erstellen. Diese Berichte können Informationen über Benutzer, Gruppen, Computer und andere Ressourcen enthalten und zur Überwachung von Sicherheit und Compliance verwendet werden.

Backup

Die Verwendung von Skripten ist möglich, um automatisch Backups von Active Directory-Daten zu erstellen. Diese Backups können verwendet werden, um Datenverluste zu vermeiden und Active Directory schnell wiederherzustellen, wenn Probleme auftreten.

Fazit

Zur Automatisierung von Active Directory-Aufgaben bieten Scripte eine hervorragende Möglichkeit. Die Verwaltung von komplexen IT-Infrastrukturen wird maßgeblich vereinfacht. Zeit wird gespart und Fehler reduziert. Es ist jedoch wichtig, dass Skripte sorgfältig geprüft und getestet werden, bevor sie in der Produktionsumgebung eingesetzt werden.

Weitere Infos dazu bei Microsoft.

Kategorien
Scripte

Powershell zur Prozessautomatisierung

Powershell Logo

Überblick und Einführung

PowerShell ist eine von Microsoft entwickelte Befehlszeilenschnittstelle und Skriptsprache, die auf der .NET Framework-Plattform basiert. Mit PowerShell können Benutzer komplexe Verwaltungs- und Automatisierungsaufgaben ausführen, indem sie PowerShell-Skripte schreiben oder PowerShell-Befehle direkt in der PowerShell-Konsole ausführen.

Also ist PowerShell ein leistungsstarkes Werkzeug für Systemadministratoren, Entwickler und IT-Profis, die in einer Windows-Umgebung arbeiten. Es bietet also zahlreiche Funktionen und Tools, mit denen Benutzer Systemkonfigurationen verwalten, Dateien und Ordner verwalten, Prozesse verwalten, Datenbanken verwalten, Netzwerkeinstellungen konfigurieren und vieles mehr.

PowerShell ist sehr flexibel und kann nahtlos mit anderen Microsoft-Tools und -Technologien wie Active Directory, Exchange Server, SharePoint, SQL Server und Windows Server integriert werden. Anders ausgedrückt kann Powershell auch mit anderen Nicht-Microsoft-Plattformen und Tools wie Linux und Docker integriert werden.

Daher ist PowerShell eine Skriptsprache, die auf der Syntax von C# basiert. Benutzer können Variablen definieren, Schleifen und Bedingungen verwenden, Funktionen und Module erstellen und vieles mehr. PowerShell-Skripte können folglich auch zur Automatisierung von Aufgaben und zur Verwaltung von Systemen auf verschiedenen Computern verwendet werden.

Insgesamt ist PowerShell ein leistungsstarkes und flexibles Werkzeug, mit dem Benutzer komplexe Aufgaben automatisieren und Systeme effizient verwalten können.

Powershell und Active Directory

PowerShell und Active Directory sind beide Produkte von Microsoft und können zusammen verwendet werden, um die Verwaltung von Benutzerkonten, Gruppen und anderen Active-Directory-Objekten zu vereinfachen.

Active Directory ist ein Verzeichnisdienst von Microsoft, der es Unternehmen ermöglicht, Benutzerkonten, Gruppen, Computer und andere Ressourcen in einer zentralisierten Datenbank zu speichern und zu verwalten. Active Directory ermöglicht es IT-Administratoren, die Zugriffsrechte auf Ressourcen zu verwalten, Gruppenrichtlinien anzuwenden und andere Verwaltungsaufgaben auszuführen.

PowerShell ist eine Skript-Sprache und Kommandozeilen-Schnittstelle von Microsoft, mit der IT-Administratoren die Verwaltung von Active-Directory-Objekten automatisieren und vereinfachen können. PowerShell bietet eine Vielzahl von Cmdlets (Befehlen), die speziell für die Verwaltung von Active Directory entwickelt wurden. Diese Cmdlets ermöglichen es IT-Administratoren, Active-Directory-Objekte wie Benutzerkonten, Gruppen, Organisationsstrukturen und andere Ressourcen zu erstellen, zu ändern und zu verwalten.

Mit PowerShell können IT-Administratoren auch komplexe Aufgaben automatisieren, die normalerweise zeitaufwändig und fehleranfällig sind. Wie die Migration von Benutzerkonten von einem Domänencontroller auf einen anderen oder die Automatisierung von Benutzerkennwortänderungen. PowerShell ermöglicht es auch, Active-Directory-Objekte in großen Mengen zu ändern oder zu löschen. Das bedeutet, dass nicht jeder einzelne Eintrag manuell bearbeitet werden muss.

Insgesamt können PowerShell und Active Directory zusammen verwendet werden, um die Verwaltung von Benutzerkonten, Gruppen und anderen Active-Directory-Objekten zu vereinfachen und zu automatisieren. Das verbessert die Effizienz und Genauigkeit der IT-Verwaltung.

Mehr und auch tiefergehende Informationen findet ihr auf den Learning Seiten bei Microsoft.

Kategorien
Scripte

How to create a AD contact?

Binäre Darstellung

Hier gibt es den Source Code um in einer Active Directory Struktur Kontakte anzulegen.

Was wird dafür benötigt?

Ihr müsst über die nötigen Rechte verfügen. Ihr braucht ein Rohdaten, wie immer aus einer Textdatei mit den gültigen Daten. Die Eingangsdatei prüfe ich nicht auf Fehler. Das muss vorab erfolgen, oder ihr programmiert diese Funktion aus und setzt diese dann vor die eigentliche Importfunktion.

Kategorien
Scripte

How to read Active Direktory Users?

Binäre Darstellung

Vorgestellt wird hier ein Source Code für Visual Basic 6 zum Auslesen eines Active Directory und Erstellung einer Userdatei im CSV Format.
Wie oft ist es schon vorgekommen. Ihr braucht mal eben ganz schnell eine Liste aus dem AD um irgendwelche Abgleiche oder Listen zu erstellen.

Das ist es gut wenn ihr ein Script parat habt welches die Rohdaten bereitstellt. Und wenn möglich auch noch recht fix. Darum habe ich mir vor einiger Zeit darüber Gedanken gemacht. Daraufhin entstand dieses kleine Script.

Ausgegeben werden:

  • SAMAccountname -> Anmeldename
  • Lastname -> Nachname
  • Givenname -> Vorname
  • TelephoneNumber -> hinterlegte Telefonnummer
  • Mail -> Mailadresse
  • location -> Standort, wenn eingetragen natürlich
  • street -> Straße
  • LDAP-Pfad -> Pfad in der AD Struktur
  • Department -> Abteilung
  • HomeDirectory -> persönliches Laufwerk
  • LogonScript -> verwendetes, dem Benutzer zugewiesenes Anmeldescript
  • IsAccountLocked -> Ist der Account gesperrt?
  • userWorkstations – w
  • Wenn eingetragen, an welchen Computerobjekten ist eine Anmeldung erlaubt.
Dim objAs, objUser, sUser, oDomain, oComputer
Dim ListeOU(5000), strLDAPQuery, objCON, Anzahl, Bereich
Kategorien
Scripte

How to modify an Active Directory

Binäre Darstellung

Worum geht es?

Die Directory Tools entstanden während meiner Einarbeitung in Active Directory und während meiner MCSE – Prüfungsvorbereitung. 2002 entstanden die ersten Tools separat als kleine Skripte, wurden erweitert und verbessert wenn es nötig war.

Nach häufigem Einsatz habe ich mich dann entschlossen die Tools in einer Oberfläche zusammen zu fassen. Zweite Stufe war die Erweiterung für Mehr-Domänen-Betrieb. Derzeit ist das Einlesen von Text oder Excel-Dateien nicht implementiert, da ich gerad an einer Überarbeitung dieser Features arbeite.

Geplant ist weiterhin eine Umstellung auf .NET. (wobei ich nicht weiß wann ich das machen soll. Zusammengefasst: Das Tool ist sowohl spezifisch auf eine Domain und die daraus resultierenden Anfragen bezogen, kann aber auch problemlos erweitert werden.

Eine Umsetzung auf .net wird mit Sicherheit nicht erfolgen. Inzwischen benutze ich für alle Aufgaben rund um ein Active Directory Struktur die Powershell. Das ist einfacher und erfüllt sehr gut seinen Zweck.

Kategorien
Scripte

How to create multiple AD groups?

CSS Programming Image

Ziel:

Das Ziel ist die Anlage von Active Directory Gruppen für die Datei- und Ordnerberechtigungen.

Angelegt wird eine domainlokale und eine globale Gruppe. Beide werden verschachtelt. (globale Gruppe als Mitglied der domainlokalen Gruppe).

Etwaige Benutzerobjekte werden dann im Anschluss (manuell) in die erzeugte globale Gruppe aufgenommen.

Angepasst werden muss je nach Bedarf Ablageort (OU) für eure spezifische Umgebung.

'Lokale und Globale Gruppe anlegen, verschachteln und Beschreibung setzen
Const ADS_GROUP_TYPE_GLOBAL_GROUP = 2
Const ADS_GROUP_TYPE_DOMAIN_LOCAL_GROUP = 4
Const ADS_GROUP_TYPE_UNIVERSAL_GROUP = 8
Const ADS_GROUP_TYPE_SECURITY_ENABLED = &h80000000

Name=InputBox("Gruppennamen?","Userinput")

G_Group = Name + "GLOBAL"
L_Group = Name + "LOCAL"

' GetObject
Set ou = GetObject("LDAP://rootdse")

Set gruppe = ou.Create("group", "cn=" + G_Group)
gruppe.sAMAccountName = G_Group
gruppe.groupType = ADS_GROUP_TYPE_GLOBAL_GROUP_
 + ADS_GROUP_TYPE_SECURITY_ENABLED
gruppe.SetInfo
Set gruppe_G = ou.GetObject("group", "cn=" + G_Group)

' GetObject
Set ou = GetObject("LDAP://rootdse")

Set gruppe = ou.Create("group", "cn=" + L_Group)
gruppe.sAMAccountName = L_Group
gruppe.groupType = ADS_GROUP_TYPE_DOMAIN_LOCAL_GROUP_
 + ADS_GROUP_TYPE_SECURITY_ENABLED
gruppe.SetInfo
Set gruppe_L = ou.GetObject("group", "cn=" + L_Group)

gruppe_L.Add gruppe_G.ADsPath

MsgBox "Gruppen angelegt sowie globale in lokale Gruppe aufgenommen."

Die Ausführung bestimmter Tools erfordert spezielle Rechte (administrativer Art). Ich übernehme keinerlei Gewährleistung für evtl. auftretende Schäden. Sie benutzen das Tool auf eigene Gefahr. Bitte sichern Sie zuvor Ihre Daten!

Michael Leidig

Bei Fragen benutzt das Kontaktformular.

Kategorien
Scripte

How to set Active Directory Profile

Binäre Darstellung

Active Directory set ProfilePath

Diese Prozedur setzt im Active Directory pro Organisationseinheit den Profilpfad aller enthaltener Userobjekte. Der UNC Pfad zu dem Profil wird angegeben. Das Verzeichnis selbst wird gleich dem Anmeldenamen gesetzt. Der LDAP Pfad wird am Anfang aus der Domain extrahiert.

Dim objAs, objUser, sUser, oDomain, oComputer
Dim group As IADsGroup
Dim Container As IADsContainer
Dim user As IADsUser
Dim computer As IADsComputer
Dim ListeOU(1000)
Dim strLDAPQuery ' As String
Dim objCON ' As ADODB.Connection
Dim W$, Anzahl
Dim BS, Ver, CName, WS
Dim Bereich
AnzahlOU = 1
Kontrollfeld.Text = ""
On Error Resume Next
Kontrollfeld.Text = ""
Set objCON = CreateObject("ADODB.Connection")
CONSTRING = "Provider=ADSDSOObject"
objCON.Open CONSTRING

Dim dc(10)
tmp = Domain.Text
i = 1
While (InStr(1, tmp, ".")) <> 0
laenge = Len(tmp)
punkt = InStr(1, tmp, ".")
dc(i) = Left(tmp, punkt - 1) & ","
rest = laenge - punkt
tmp = Right(tmp, rest)
i = i + 1
Wend
dc(i) = tmp
For K = 1 To i
  DomSTR2 = DomSTR2 & "dc=" & dc(K)
Next K
DomSTR = Domain.Text & "/" & DomSTR2 & ">"
strLDAPQuery = "

Wie immer, ihr benutzt die Prozeduren auf eigene Gefahr. Ihr benötigt hierfür teilweise Adminrechte. Prüft in einem Testsystem ob alles so funktioniert wie ihr wollt.

Kategorien
Scripte

How to create Active Directory User

Binäre Darstellung

Benutzer im Active Directory erzeugen

Ihr wollt nicht immer wieder die Active Directory (AD)-Benutzer MMC öffnen, herum klicken, Tippfehler machen und zum x-ten Mal ein neues Benutzerkonto erstellen? Wenn dies der Fall ist, ist es Zeit das Hinzufügen eines Benutzers zu automatisieren.

Wie meistens existieren hierfür mehrere Wege, die alle zum Ziel führen.
Der Erste ist, einen Benutzer mittels Script anzulegen und die benötigten Attribute mitzugeben.
Ein Zweiter Weg ist, einen vorhandenen Benutzer zu kopieren. In dem Fall ist ein Referenzobjekt erforderlich. Die dritte Möglichkeit besteht darin mittels einer csv-Liste die Objekte und Eigenschaften zu übermitteln.

Für welchen Weg ihr euch entscheidet müsst ihr selbst festlegen.

Code

Hier ist der zentrale Source Code zu der Prozedur User anlegen.
Anpassen müsst ihr nur Domain, und natürlich eine Userliste bereitstellen.

'User anlegen in der root der Domain
Private Sub mnu_User_Create_Click()
Dim objAs, sUser, sOU, sGroup
Dim Container As IADsContainer
Dim user As IADsUser
Dim objUser
'Variablen belegen
sLastName = cNachname.Text
sGivenName = cVorname.Text
sFullname = sLastName & " " & sGivenName
sDescription = "User"
Set adsi = GetObject("LDAP:")
Dim dc(10)

tmp = Domain.Text
i = 1
While (InStr(1, tmp, ".")) <> 0
laenge = Len(tmp): punkt = InStr(1, tmp, "."):_
dc(i) = Left(tmp, punkt - 1) & ",": rest = laenge - punkt
tmp = Right(tmp, rest): i = i + 1
Wend
dc(i) = tmp
For K = 1 To i
  DomSTR2 = DomSTR2 & "dc=" & dc(K)
Next K
DomSTR = Domain.Text & "/" & DomSTR2
  Set objAs = adsi.OpenDSObject("LDAP://" &_
  DomSTR, admin.Text, adminpwd.Text, 1)
  Set objUser = objAs.Create("User", "CN=" & sFullname)
  objUser.FullName = sFullname
  objUser.Description = sDescription
  objUser.LastName = sLastName
  objUser.GivenName = sGivenName
  objUser.Put "company", "Company"
  
  objUser.Put "samAccountname", LCase(cAccountname)
  objUser.Put "UserPrincipalName",_
  LCase(cAccountname) & "@" & Domain
  objUser.SetInfo
Kontrollfeld.Text = Err.Number & " ; " & Err.Description
  Err.Clear
  
  Set user = adsi.OpenDSObject("LDAP://" &_
  Domain & "/" & "CN=" & sFullname & "," &_
  DomSTR2, admin.Text, adminpwd.Text, 1)
  Set Container = GetObject(user.Parent)
  user.AccountDisabled = False
  user.SetPassword (cpassword.Text)
  user.SetInfo
  If Err.Number = 0 Then cerror =_
  "User erfolgreich angelegt" Else cerror =_
  Err.Number & " ; " & Err.Description
  Kontrollfeld.Text = cerror
  Err.Clear
End Sub

Dieses Scriptstück ist inzwischen etwas in die Jahre gekommen.

Inzwischen verwende ich Powershell zur Lösung derartiger Aufgaben. Mit New-ADUser erreicht ihr hier einen besseren Code bei der Umsetzung. Hier nur ein Beispiel.

New-ADUser -Name "h.muster" -OtherAttributes @{'title'="your title";'mail'="h.muster@yourdomain.de"}

Es ist auch sehr einfach alle bekannten Attribute bei der Anlage mitzugeben wie Passwort, Standort, Organisation, Homelaufwerk, Gültigkeitszeitraum, Telefondaten, Stadt usw. Toll daran ist, ihr könnt das mit einem einzigen Powershell Befehl umsetzen.

Vorrausetzungen:

  • Windows PowerShell 5.1 auf eurem Rechner muss vorhanden sein.
  • Remote Server Administration Tools (RSAT). Dieses Paket installiert das Active Directory PowerShell Modul welches das New-AdUser cmdlet beinhaltet.
  • Ihr müsst an einem Rechner angemeldet sein, der Mitglied der Domain ist in der ihr die User anlegen wollt.
  • Der benutzte AD Account muss über die Berechtigungen verfügen Bentzer anzulegen.

Diesen Code verwendet ihr auf eigene Gefahr. Voraussetzung sind entsprechende Berechtigungen auf die AD Struktur. Ich übernehme keine Gewährleistung.

Michael Leidig
Kategorien
Scripte

Einfacher AD Import mit LDIF (EXL2LDIF)

CSS Programming Image

LDIF steht für LDAP Data Interchange Format und ist das Format der Wahl wenn ihr in einer Active Directory Struktur Massenänderungen durchführen wollt.

Ein LDAP-Objekt wird durch mehrere LDIF-Zeilen beschrieben. Am Anfang steht immer der distinguished name dn, der die absolute Position im LDAP-Baum angibt. Es folgen Objektklassen, die definieren, welche Attribute zulässig oder vorgeschrieben sind. 

Beispiel:

dn: dc=struktur, dc=de
objectclass: organization
objectclass: top
o: struktur

Es existieren zwei grundlegende LDIF Formate, LDIF Change und LDIF Change. Letzterer enthält die Änderungen an einem Objekt.

Ziel:

Das Script wandelt eine Excel Tabelle in das LDIF Format um, zum weiteren Import in eine Active Directory Struktur.

Private Sub Excel2LDIF_Click()

'LDIF Ausgabe aus Excelliste
Dim oAs, oUser As Object
Dim xlApp As Object
Dim zaehler
Dim ADSI As Object
Dim OUTeil(256) As String

'On Error Resume Next

Set xlApp = CreateObject(pfad_tabelle.Caption)
xlApp.Application.Visible = False
xlApp.Windows(1).Visible = False

On Error Resume Next

With CommonDialog1
  .CancelError = True
  .Flags = cdlOFNOverwritePrompt
  .Filter = "Textdateien (*.LDIF)|*.LDIF"
  .ShowSave
  If .FileName <> "" Then
    F = FreeFile
    Open .FileName For Output As #F
  End If
End With

' Ermittlung der Anzahl Datensaetze und Prüfung
Fehleranzahl = 0 ' Fehleranzahl

Kontrollfeld.Text = Kontrollfeld.Text & "Prüfung !!!" & vbCrLf
AnzahlDatensaetze = 2
While (xlApp.Worksheets(1).Range("A" & AnzahlDatensaetze).Value) <> ""
  If Trim(xlApp.Worksheets(1).Range("C" & AnzahlDatensaetze).Value) = "" Then
    Fehleranzahl = Fehleranzahl + 1
  End If
  If Trim(xlApp.Worksheets(1).Range("D" & AnzahlDatensaetze).Value) = "" Then
    Fehleranzahl = Fehleranzahl + 1
  End If
  If Trim(xlApp.Worksheets(1).Range("E" & AnzahlDatensaetze).Value) = "" Then
    Fehleranzahl = Fehleranzahl + 1
  End If
  If Trim(xlApp.Worksheets(1).Range("G" & AnzahlDatensaetze).Value) = "" Then
    Fehleranzahl = Fehleranzahl + 1
  End If
  AnzahlDatensaetze = AnzahlDatensaetze + 1
Wend

If Fehleranzahl > 0 Then
  Antwort = MsgBox("Anzahl fehlerhafter Datensätze: " & Fehleranzahl, vbYesNo + vbExclamation, "Wollen Sie eine LDIF - Ausgabe erstellen?")
  If Antwort = vbOK Then
  Else
    Print #F, Kontrollfeld.Text
    Close #F
    Unload Form1
    Exit Sub
    xlApp.Application.Quit
  End If
End If

' Start Bearbeitung
zaehler = 2
While (xlApp.Worksheets(1).Range("A" & zaehler).Value) <> ""

'Refresh der Anzeige
Form1.Refresh
Kontrollfeld.Refresh

'Schreibe LDIF

'Variablen belegen
'---------------------------------------------------------------------------
    'Variable Werte aus Tabelle --------------------------------------------

    Datum = Format$(Now, "yy.mm.dd")
    Tag = Right(Datum, 2)
    Monat = Mid(Datum, 4, 2)
    Jahr = Left(Datum, 2)
    Zeit = Format$(Now, "hh:nn:ss")
    Min = Mid(Zeit, 4, 2)
    St = Left(Zeit, 2)

    If zaehler > 9 Then
      employeeNumber = "E" & Jahr & Monat & Tag & St & zaehler & "1"
    Else
      employeeNumber = "E" & Jahr & Monat & Tag & St & Min & zaehler
    End If

    sn = Trim(xlApp.Worksheets(1).Range("C" & zaehler).Value) 'Nachname
    givenName = Trim(xlApp.Worksheets(1).Range("D" & zaehler).Value) 'Vorname

    ' - berechneter Wert aus Tabelle ---------------------------------------
    Print #F, "dn: cn=" & sn & " " & givenName & " " & employeeNumber & "," & "cn=Users,cn=XXXXXX"
    Print #F, "cn: " & sn & " " & givenName & " " & employeeNumber 
    Print #F, "employeeNumber: " & employeeNumber
    Print #F, "sn: " & Trim(xlApp.Worksheets(1).Range("C" & zaehler).Value) 
    Print #F, "givenName: " & Trim(xlApp.Worksheets(1).Range("D" & zaehler).Value)

    ' Prüfung auf Firma vorhanden wenn ja dann Excelliste wenn nein ="extern"

    If UCase(Trim(xlApp.Worksheets(1).Range("H" & zaehler).Value)) = "" Then
      Print #F, "Company: EXTERN 'Firma =xxx"
    Else
      Print #F, "Company: " & UCase(Trim(xlApp.Worksheets(1).Range("H" & zaehler).Value)) 
    End If
    Print #F, "Salutation: " & Trim(xlApp.Worksheets(1).Range("B" & zaehler).Value)

    OU = UCase(Trim(xlApp.Worksheets(1).Range("E" & zaehler).Value))
    K = 1
    OUTeil(K) = UCase(Trim(xlApp.Worksheets(1).Range("E" & zaehler).Value)) '(1)
    K = K + 1
    While (InStrRev(OU, "-")) <> 0
      Position = (InStrRev(OU, "-"))
      OUTeil(K) = Left(OU, Position - 1)
      OU = Left(OU, Position - 1)
      K = K + 1
    Wend
    OU = "OU: ou="
    For J = 1 To K - 1
    If J = K - 1 Then
      OU = OU & OUTeil(J)
    Else
      OU = OU & OUTeil(J) & ",ou="
    End If
    Next J
    OU = OU & ",o=xxx,cn=xxx"
    Print #F, OU

    'Kostenstelle
    Print #F, "Kostenstelle: " & UCase(Trim(xlApp.Worksheets(1).Range("G" & zaehler).Value)) 'Kostenstelle

    ' ADS User Typ auswerten -> Base OU bestimmen START
    ADOU = UCase(Trim(xlApp.Worksheets(1).Range("K" & zaehler).Value)) 
    Select Case ADOU
    Case "1"
      ADOU = "OU=Users,"
    Case "2"
      ADOU = "OU=Users,"
    Case "3"
      ADOU = "OU=Users,"
    Case Else
      ADOU = "OU=Users,"
    End Select
    Print #F, "ADOU: " & ADOU

    Print #F, "AD: " & Trim(xlApp.Worksheets(1).Range("I" & zaehler).Value) 'AD Status

    Print #F, vbCrLf

  zaehler = zaehler + 1
Wend
Close #F
xlApp.Application.Quit
End Sub

Diesen Code verwendet ihr auf eigene Gefahr. Voraussetzung sind entsprechende Berechtigungen auf die AD Struktur. Ich übernehme keine Gewährleistung.

Michael Leidig