Kategorie: PowerShell

# Standardansicht für einen bestimmten Benutzer
Get-UserLoginHistory -Username "Samaaccountname"

# Interaktive GridView-Anzeige
Get-UserLoginHistory -ViewType Grid

# Auf einzelnem DC mit höherem Limit für mehr Ergebnisse
Get-UserLoginHistory -DomainControllers "domaincontroller" -MaxEvents 5000 -ViewType Full

# Schnellerer Export ohne Anzeige
Get-UserLoginHistory -Hours 48 -ExportToCsv -ViewType None

function Get-UserLoginHistory {
  <#
  .SYNOPSIS
      Ermittelt den Anmeldeverlauf von Benutzern aus den Sicherheitsprotokollen der Domain-Controller.
  
  .DESCRIPTION
      Diese Funktion durchsucht die Sicherheitsprotokolle aller oder bestimmter Domain-Controller
      nach Anmeldeereignissen (4624, 4625) und zeigt Details zu diesen Anmeldungen in einer übersichtlichen Form an.
      Die Funktion wurde für bessere Performance optimiert.
      
  .PARAMETER Username
      Optional. Der Benutzername, nach dem gesucht werden soll. Kann im Format "Benutzername", 
      "Domain\Benutzername" oder "[email protected]" angegeben werden.
  
  .PARAMETER DomainControllers
      Optional. Eine Liste von Domain-Controllern, die durchsucht werden sollen.
      Wenn nicht angegeben, werden alle Domain-Controller der aktuellen Domäne durchsucht.
  
  .PARAMETER Hours
      Optional. Die Anzahl der Stunden in der Vergangenheit, die durchsucht werden sollen.
      Standard: 24 Stunden
  
  .PARAMETER MaxEvents
      Optional. Die maximale Anzahl von Ereignissen, die pro Domain-Controller abgerufen werden sollen.
      Standard: 1000 Ereignisse
  
  .PARAMETER ExportToCsv
      Optional. Exportiert die Ergebnisse in eine CSV-Datei.
  
  .PARAMETER LogFilePath
      Optional. Pfad zur CSV-Datei, wenn ExportToCsv aktiviert ist.
      Standard: "C:\Logs\UserLoginHistory.csv"
  
  .PARAMETER ViewType
      Optional. Art der Anzeige der Ergebnisse:
      - Table: Kompakte Tabellendarstellung (Standard)
      - Full: Ausführliche Tabellendarstellung
      - Grid: Anzeige im Out-GridView-Dialog (interaktiv)
      - None: Keine Anzeige, nur Rückgabe der Objekte
  
  .EXAMPLE
      Get-UserLoginHistory -Username "mustermann"
      Zeigt die Anmeldungen des Benutzers "mustermann" der letzten 24 Stunden an.
  
  .EXAMPLE
      Get-UserLoginHistory -Username "mustermann" -Hours 48 -MaxEvents 5000 -ViewType Grid
      Zeigt die Anmeldungen des Benutzers "mustermann" der letzten 48 Stunden im GridView-Dialog an.
  
  .EXAMPLE
      Get-UserLoginHistory -DomainControllers "DC01.domain.com" -ExportToCsv
      Zeigt Anmeldungen vom angegebenen Domain-Controller und exportiert sie in eine CSV-Datei.
  
  .NOTES
      Erfordert entsprechende Berechtigungen zum Lesen der Sicherheitsprotokolle der Domain-Controller.
		Dateiname:      Get-UserLoginHistory.ps1
  	Autor:          Ismahil Ahmed
  	Erstelldatum:   12.02.2025
  	Version:        1.6
  #>
  
  [CmdletBinding()]
  param (
      [Parameter(Mandatory=$false, Position=0)]
      [string]$Username,
      
      [Parameter(Mandatory=$false)]
      [string[]]$DomainControllers,
      
      [Parameter(Mandatory=$false)]
      [int]$Hours = 24,
      
      [Parameter(Mandatory=$false)]
      [int]$MaxEvents = 1000,
      
      [Parameter(Mandatory=$false)]
      [switch]$ExportToCsv,
      
      [Parameter(Mandatory=$false)]
      [string]$LogFilePath = "C:\Logs\UserLoginHistory.csv",
      
      [Parameter(Mandatory=$false)]
      [switch]$IncludeFailedLogins = $true,
      
      [Parameter(Mandatory=$false)]
      [ValidateSet("Table", "Full", "Grid", "None")]
      [string]$ViewType = "Table"
  )
  
  begin {
      # Optimierung: Verwende RunspacePool für parallele Verarbeitung
      $runspacePool = [runspacefactory]::CreateRunspacePool(1, [Environment]::ProcessorCount)
      $runspacePool.Open()
      $runspaces = @()
      $scriptBlock = {
          param (
              [string]$DomainController,
              [datetime]$StartTime,
              [datetime]$EndTime,
              [int[]]$EventIDs,
              [int]$MaxEventsToGet,
              [string]$UserFilter,
              [string]$UserDomain,
              [string]$UserPrincipalName
          )
          
          # Ergebnisstruktur
          $results = @{
              DC = $DomainController
              Success = $false
              Events = @()
              Error = $null
              EventCount = 0
              ProcessedCount = 0
              MatchedCount = 0
          }
          
          try {
              # Teste Verbindung
              if (-not (Test-Connection -ComputerName $DomainController -Count 1 -Quiet)) {
                  $results.Error = "Domain-Controller nicht erreichbar"
                  return $results
              }
              
              # Erstelle FilterHashtable
              $filter = @{
                  LogName = 'Security'
                  ID = $EventIDs
                  StartTime = $StartTime
                  EndTime = $EndTime
              }
              
              # Versuche Zugriff zu testen
              try {
                  $null = Get-WinEvent -ComputerName $DomainController -LogName Security -MaxEvents 1 -ErrorAction Stop
              }
              catch {
                  $results.Error = "Zugriff auf Sicherheitsprotokolle nicht möglich: $($_.Exception.Message)"
                  return $results
              }
              
              # Hauptabfrage - OPTIMIERT durch limitierte Feldabfrage
              $events = Get-WinEvent -ComputerName $DomainController -FilterHashtable $filter -MaxEvents $MaxEventsToGet -ErrorAction Stop
              
              $results.EventCount = $events.Count
              $results.Success = $true
              
              # Verarbeite Ereignisse - OPTIMIERT durch selektive Verarbeitung
              foreach ($event in $events) {
                  $results.ProcessedCount++
                  
                  try {
                      $eventXml = [xml]$event.ToXml()
                      $eventData = $eventXml.Event.EventData.Data
                      
                      # Extrahiere Benutzernamen
                      $targetUsername = ($eventData | Where-Object { $_.Name -eq 'TargetUserName' }).'#text'
                      $targetDomain = ($eventData | Where-Object { $_.Name -eq 'TargetDomainName' }).'#text'
                      
                      # Benutzernamen vergleichen, wenn ein Benutzerfilter angegeben ist
                      $matchUser = $true
                      if ($UserFilter) {
                          $matchUser = $false
                          
                          # Vereinfachte Matching-Strategien für bessere Performance
                          if ($targetUsername -eq $UserFilter) {
                              $matchUser = $true
                          }
                          elseif ($UserDomain -and ($targetDomain -like "*$UserDomain*") -and ($targetUsername -eq $UserFilter)) {
                              $matchUser = $true
                          }
                          elseif ($UserPrincipalName -and ("$targetUsername@$targetDomain" -like "*$UserPrincipalName*")) {
                              $matchUser = $true
                          }
                      }
                      
                      # Nur Benutzeranmeldungen (keine Systemkonten)
                      if ($matchUser -and 
                          $targetUsername -notmatch '^\$' -and 
                          $targetUsername -ne 'ANONYMOUS LOGON' -and
                          $targetUsername -ne 'SYSTEM' -and
                          $targetUsername -ne 'LOCAL SERVICE' -and
                          $targetUsername -ne 'NETWORK SERVICE') {
                          
                          $results.MatchedCount++
                          
                          # Extrahiere nur die minimal notwendigen Informationen
                          $ipAddress = ($eventData | Where-Object { $_.Name -eq 'IpAddress' }).'#text'
                          if ([string]::IsNullOrEmpty($ipAddress) -or $ipAddress -eq '-') {
                              $ipAddress = "Lokal"
                          }
                          
                          $workstation = ($eventData | Where-Object { $_.Name -eq 'WorkstationName' }).'#text'
                          if ([string]::IsNullOrEmpty($workstation)) {
                              $workstation = "Unbekannt"
                          }
                          
                          $logonType = ($eventData | Where-Object { $_.Name -eq 'LogonType' }).'#text'
                          $logonTypeDesc = switch ($logonType) {
                              2 { "Interaktiv" }
                              3 { "Netzwerk" }
                              4 { "Batch" }
                              5 { "Dienst" }
                              7 { "Entsperrt" }
                              8 { "NetworkCleartext" }
                              9 { "NewCredentials" }
                              10 { "RemoteInteraktiv" }
                              11 { "CachedInteraktiv" }
                              default { "Typ $logonType" }
                          }
                          
                          $results.Events += [PSCustomObject]@{
                              Zeitstempel = $event.TimeCreated
                              DC = $DomainController
                              Benutzername = "$targetDomain\$targetUsername"
                              IPAdresse = $ipAddress
                              Computername = $workstation
                              EreignisID = $event.Id
                              Status = if ($event.Id -eq 4624) { "Erfolgreich" } else { "Fehlgeschlagen" }
                              AnmeldungsTyp = $logonTypeDesc
                          }
                      }
                  }
                  catch {
                      # Ignoriere einzelne Fehler bei der Ereignisverarbeitung
                      continue
                  }
              }
          }
          catch {
              if ($_.Exception.Message -like "*Es wurden keine Ereignisse gefunden*") {
                  $results.Success = $true
                  $results.EventCount = 0
              }
              else {
                  $results.Error = $_.Exception.Message
              }
          }
          
          return $results
      }
      
      # Erstellen des Log-Verzeichnisses, falls es nicht existiert und Export aktiviert ist
      if ($ExportToCsv) {
          $logDir = Split-Path $LogFilePath -Parent
          if (-not (Test-Path $logDir)) {
              New-Item -ItemType Directory -Path $logDir -Force | Out-Null
          }
      }
      
      # Funktion zum Abrufen von Domain-Controller-Namen
      function Get-DCList {
          try {
              # Verwende Get-ADDomainController falls RSAT-Tools installiert sind
              if (Get-Command Get-ADDomainController -ErrorAction SilentlyContinue) {
                  return (Get-ADDomainController -Filter * | Select-Object -ExpandProperty HostName)
              } else {
                  # Fallback-Methode
                  $domain = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()
                  return $domain.DomainControllers | ForEach-Object { $_.Name }
              }
          } catch {
              Write-Warning "Fehler beim Abrufen der Domain-Controller: $_"
              return $null
          }
      }
      
      # Zeitraum berechnen
      $endTime = Get-Date
      $startTime = $endTime.AddHours(-$Hours)
      
      Write-Host "Suche nach Anmeldeereignissen zwischen $($startTime.ToString('yyyy-MM-dd HH:mm:ss')) und $($endTime.ToString('yyyy-MM-dd HH:mm:ss'))" -ForegroundColor Cyan
      
      # Ereignis-IDs festlegen
      if ($IncludeFailedLogins) {
          $eventIDs = @(4624, 4625)  # Erfolgreiche und fehlgeschlagene Anmeldungen
      } else {
          $eventIDs = @(4624)  # Nur erfolgreiche Anmeldungen
      }
      
      # Wenn keine Domain-Controller angegeben wurden, versuche, sie abzurufen
      if (-not $DomainControllers) {
          $DomainControllers = Get-DCList
          if (-not $DomainControllers) {
              Write-Error "Keine Domain-Controller gefunden. Bitte gib explizit Domain-Controller an."
              return
          }
      }
      
      Write-Host "Domain-Controller: $($DomainControllers -join ', ')" -ForegroundColor Cyan
      
      # Benutzernamenformat verarbeiten
      $userSamAccountName = $null
      $userDomain = $null
      $userPrincipalName = $null
      
      if ($Username) {
          Write-Host "Suche nach Benutzername: $Username" -ForegroundColor Cyan
          
          # Prüfe verschiedene Formate
          if ($Username -match '^(.+)\\(.+)$') {
              # Format: DOMAIN\username
              $userDomain = $Matches[1]
              $userSamAccountName = $Matches[2]
              Write-Host "  Format erkannt: DOMAIN\username (Domäne: $userDomain, Benutzername: $userSamAccountName)" -ForegroundColor Yellow
          }
          elseif ($Username -match '^(.+)@(.+)$') {
              # Format: [email protected]
              $userSamAccountName = $Matches[1]
              $userDomain = $Matches[2]
              $userPrincipalName = $Username
              Write-Host "  Format erkannt: [email protected] (Benutzername: $userSamAccountName, Domäne: $userDomain)" -ForegroundColor Yellow
          }
          else {
              # Format: username
              $userSamAccountName = $Username
              Write-Host "  Format erkannt: Nur Benutzername (Benutzername: $userSamAccountName)" -ForegroundColor Yellow
              
              # Versuche, den vollständigen Benutzernamen aus Active Directory zu bekommen
              if (Get-Command Get-ADUser -ErrorAction SilentlyContinue) {
                  try {
                      $adUser = Get-ADUser -Identity $userSamAccountName -Properties UserPrincipalName, DistinguishedName
                      if ($adUser) {
                          $userPrincipalName = $adUser.UserPrincipalName
                          $userDomain = ($adUser.DistinguishedName -split ',DC=')[1]
                          Write-Host "  AD-Benutzerinformationen gefunden: $($adUser.DistinguishedName)" -ForegroundColor Green
                      }
                  }
                  catch {
                      Write-Warning "  Konnte keine AD-Benutzerinformationen für '$userSamAccountName' finden: $_"
                  }
              }
          }
      }
  }
  
  process {
      # Starte die parallele Verarbeitung der Domain-Controller
      Write-Host "`nStarte parallele Abfrage von $($DomainControllers.Count) Domain-Controllern..." -ForegroundColor Yellow
      
      foreach ($dc in $DomainControllers) {
          $runspaceParams = @{
              DomainController = $dc
              StartTime = $startTime
              EndTime = $endTime
              EventIDs = $eventIDs
              MaxEventsToGet = $MaxEvents
              UserFilter = $userSamAccountName
              UserDomain = $userDomain
              UserPrincipalName = $userPrincipalName
          }
          
          $runspace = [powershell]::Create().AddScript($scriptBlock).AddParameters($runspaceParams)
          $runspace.RunspacePool = $runspacePool
          
          $runspaces += [PSCustomObject]@{
              Runspace = $runspace
              Handle = $runspace.BeginInvoke()
              DC = $dc
              Completed = $false
          }
      }
      
      # Erstelle eine ArrayList für die Ergebnisse
      $allResults = New-Object System.Collections.ArrayList
      
      # Überwache den Fortschritt der Runspaces
      $completed = 0
      $total = $runspaces.Count
      
      while ($runspaces | Where-Object { -not $_.Completed }) {
          foreach ($item in $runspaces | Where-Object { -not $_.Completed }) {
              if ($item.Handle.IsCompleted) {
                  $results = $item.Runspace.EndInvoke($item.Handle)
                  $item.Completed = $true
                  $completed++
                  
                  # Status anzeigen
                  if ($results.Success) {
                      Write-Host "Domain-Controller $($item.DC): $($results.MatchedCount) von $($results.EventCount) Ereignissen gefunden" -ForegroundColor Green
                  } else {
                      Write-Host "Domain-Controller $($item.DC): Fehler - $($results.Error)" -ForegroundColor Red
                  }
                  
                  # Ergebnisse zur Gesamtliste hinzufügen
                  if ($results.Events.Count -gt 0) {
                      [void]$allResults.AddRange($results.Events)
                  }
                  
                  # Runspace bereinigen
                  $item.Runspace.Dispose()
              }
          }
          
          # Fortschrittsanzeige aktualisieren
          Write-Progress -Activity "Abfrage von Domain-Controllern" -Status "$completed von $total abgeschlossen" -PercentComplete (($completed / $total) * 100)
          
          # Kurze Pause für CPU-Entlastung
          Start-Sleep -Milliseconds 100
      }
      
      Write-Progress -Activity "Abfrage von Domain-Controllern" -Completed
      
      # Sortiere die Ergebnisse nach Zeitstempel (neueste zuerst)
      $sortedResults = $allResults | Sort-Object -Property Zeitstempel -Descending
      
      # Gib Statistiken aus
      $resultCount = $sortedResults.Count
      Write-Host "`nGefundene Anmeldungen: $resultCount" -ForegroundColor Cyan
      
      # Exportiere zu CSV, falls gewünscht
      if ($ExportToCsv -and $resultCount -gt 0) {
          $sortedResults | Export-Csv -Path $LogFilePath -NoTypeInformation -Encoding UTF8
          Write-Host "Ergebnisse wurden in $LogFilePath gespeichert." -ForegroundColor Green
      }
      
      # Zeige die Ergebnisse je nach ViewType an
      if ($resultCount -gt 0) {
          switch ($ViewType) {
              "Table" {
                  # Kompakte Tabellendarstellung mit ausgewählten Spalten
                  $displayCount = [Math]::Min(20, $resultCount)
                  Write-Host "Zeige die neuesten $displayCount Anmeldungen in Tabellenform:" -ForegroundColor Cyan
                  
                  # Format-Table mit benutzerdefinierter Formatierung für bessere Lesbarkeit
                  $sortedResults | Select-Object -First $displayCount | 
                      Format-Table -Property @{
                          Label = "Zeitpunkt"; 
                          Expression = { $_.Zeitstempel.ToString("yyyy-MM-dd HH:mm:ss") };
                          Width = 19
                      },
                      @{
                          Label = "Benutzer"; 
                          Expression = { ($_.Benutzername -split '\\')[-1] };
                          Width = 15
                      },
                      @{
                          Label = "Status"; 
                          Expression = { 
                              if ($_.Status -eq "Erfolgreich") { 
                                  "✓" 
                              } else { 
                                  "✗" 
                              }
                          };
                          Width = 6
                      },
                      @{
                          Label = "Anmeldungstyp"; 
                          Expression = { $_.AnmeldungsTyp };
                          Width = 15
                      },
                      @{
                          Label = "IP-Adresse"; 
                          Expression = { $_.IPAdresse };
                          Width = 15
                      },
                      @{
                          Label = "Computer"; 
                          Expression = { $_.Computername };
                          Width = 15
                      },
                      @{
                          Label = "Domain-Controller"; 
                          Expression = { ($_.DC -split '\.')[0] };
                          Width = 15
                      }
                  
                  if ($resultCount -gt 20) {
                      Write-Host "... und $($resultCount - 20) weitere Anmeldungen." -ForegroundColor Yellow
                      Write-Host "Vollständige Anzeige mit 'Get-UserLoginHistory -ViewType Grid' oder 'Get-UserLoginHistory -ViewType Full'" -ForegroundColor Yellow
                  }
                  
                  # Bei Table-Ansicht keine Objekte zurückgeben
                  return
              }
              "Full" {
                  # Ausführliche Tabellendarstellung mit allen Spalten
                  Write-Host "Zeige die Anmeldungen in ausführlicher Tabellenform:" -ForegroundColor Cyan
                  $sortedResults | Format-Table -AutoSize
                  
                  # Bei Full-Ansicht keine Objekte zurückgeben
                  return
              }
              "Grid" {
                  # GridView-Darstellung (interaktiv)
                  Write-Host "Öffne interaktives GridView-Fenster mit den Ergebnissen..." -ForegroundColor Cyan
                  $sortedResults | Out-GridView -Title "Benutzeranmeldungen ($resultCount Einträge)" -PassThru
                  
                  # Bei Grid-Ansicht keine Objekte zurückgeben
                  return
              }
              "None" {
                  # Keine Anzeige, nur Rückgabe der Objekte
                  Write-Host "Keine Anzeige ausgewählt. Die Ergebnisse sind als Objekte verfügbar." -ForegroundColor Yellow
              }
          }
      }
      else {
          Write-Host "Keine Anmeldungen gefunden, die den Filterkriterien entsprechen." -ForegroundColor Yellow
      }
      
      # Gib die Ergebnisse nur zurück, wenn ViewType "None" ist oder keine Ergebnisse gefunden wurden
      # Bei anderen ViewTypes wurde die Rückgabe bereits mit "return" beendet
      return $sortedResults
  }
  
  end {
      # Runspace-Pool schließen
      $runspacePool.Close()
      $runspacePool.Dispose()
  }
}

Import-Module ActiveDirectory

Get-Module -ListAvailable ActiveDirectory
Get-Command -Module ActiveDirectory
Get-Help Get-ADUser -Detailed  # Beispiel um die Funktionsweise vom Command "Get-ADUser" zu verstehen

Get-ADUser -Filter * -SearchBase "OU=Benutzer,DC=testdomain,DC=local"
Get-ADUser -Filter * -SearchBase "OU=Benutzer,DC=testdomain,DC=local" | ft

DistinguishedName : CN=Nachname\, Vorname,OU=Benutzer, DC=testdomain,DC=local
Enabled           : True
GivenName         : Vorname
Name              : Nachname, Vorname
ObjectClass       : user
ObjectGUID        : eb3867da-5c0b-4633-b19e-e366700d1032
SamAccountName    : Anmeldename
SID               : S-1-5-21-2875105853-2476587791-2145578461-4692
Surname           :
UserPrincipalName : testuser@testdomain.local

Get-ADUser -Filter {Enabled -eq $true -and Department -eq "IT"} -Properties Department

New-ADUser -Name "Max Mustermann" `
  -GivenName "Max" `
  -Surname "Mustermann" `
  -SamAccountName "mmustermann" `
  -UserPrincipalName "[email protected]" `
  -Path "OU=Benutzer,DC=firma,DC=local" `
  -AccountPassword (ConvertTo-SecureString "Passw0rd!" -AsPlainText -Force) `
  -Enabled $true

Set-ADAccountPassword -Identity mmustermann -NewPassword (ConvertTo-SecureString "NeuesPass123!" -AsPlainText -Force) -Reset
Unlock-ADAccount -Identity mmustermann

Add-ADGroupMember -Identity "IT-Admins" -Members mmustermann

Remove-ADGroupMember -Identity "IT-Admins" -Members mmustermann -Confirm:$false

Get-ADComputer -Filter * -SearchBase "OU=Clients,DC=firma,DC=local"

Get-ADComputer -Filter * -SearchBase "OU=Clients,DC=firma,DC=local"

Get-ADUser -Filter * -Properties LastLogonDate | Select Name, LastLogonDate

Get-ADUser testuser -Properties LastLogonDate | FT -Property Name, LastLogonDate -A

Name    LastLogonDate
----    -------------
testuser  11.03.2025 09:11:49

Get-ADUser testuser -Properties LastLogonDate

DistinguishedName : CN=testuser,OU=Test,OU=Benutzer,OU=domainOU,DC=testdomain,DC=de
Enabled           : True
GivenName         : testuser
LastLogonDate     : 11.03.2025 09:11:49
Name              : testuser  
ObjectClass       : user
ObjectGUID        : adffdd6e-02a3-4651-8606-1a7ad1923cfe
SamAccountName    : testuser
SID               : S-1-5-21-2875105854-2476583791-2145578461-1438
Surname           : test
UserPrincipalName : testuser@testdomain.de

Get-ADGroupMember -Identity "Domain Admins" -Recursive

$searcher = New-Object DirectoryServices.DirectorySearcher
$searcher.SearchRoot = [ADSI]"LDAP://RootDSE" # Die root Domain
$searcher.Filter = "(&(objectCategory=User)(samAccountName=USERNAME))" # Userobjecte werden gesucht mit dem bestimmten anmeldenamen
$result = $searcher.FindOne() # FindAll()

function Get-ADUser {
    param([string]$UserName)
    return (New-Object System.DirectoryServices.DirectorySearcher("(&(objectCategory=User)(samAccountName=$UserName))")).FindOne()
}

$reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey('Users', $computer)

$reg.GetSubKeyNames() | ? {$_ -match '\d{4,5}$'}

function Get-MappedDrives {
    param (
        $computer = $env:COMPUTERNAME
    )

    $reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey('Users', $computer)
    $reg.GetSubKeyNames() | ? {$_ -match '\d{4,5}$'} | % {
        $sid = $_
        $reg.OpenSubKey("$sid\Network").GetSubKeyNames() | % {
            New-Object psobject -Property @{
                Computer = $computer
                User = ([System.Security.Principal.SecurityIdentifier]($sid)).Translate([System.Security.Principal.NTAccount]).Value
                DriveLetter = $_
                Map = $reg.OpenSubKey("$sid\Network\$_").GetValue('RemotePath')
            }
        }
    }
}

function Get-MappedDrives {
    param (
        [string]$computer = $env:COMPUTERNAME
    )

    # Prüfe ob der Host erreichbar ist, bevor weitermachen
    try {
        if (-not (Test-Connection -ComputerName $computer -Count 1 -Quiet -ErrorAction Stop)) {
            Write-Warning "Computer '$computer' ist nicht erreichbar."
            return
        }
    }
    catch {
        Write-Warning "Verbindungsfehler zu '$computer': $_"
        return
    }

    # Sammle zuerst alle Daten in einer Hashtable, gruppiert nach Benutzern
    $userDrives = @{}

    try {
        $reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey('Users', $computer)
        
        $reg.GetSubKeyNames() | ? {$_ -match '\d{4,5}$'} | % {
            $sid = $_
            $networkKey = $reg.OpenSubKey("$sid\Network")
            
            if ($networkKey) {
                try {
                    # Wandle SID in Benutzername um - nur einmal pro Benutzer
                    $userName = ([System.Security.Principal.SecurityIdentifier]($sid)).Translate([System.Security.Principal.NTAccount]).Value
                    
                    # Erstelle einen Eintrag für diesen Benutzer, falls noch nicht vorhanden
                    if (-not $userDrives.ContainsKey($userName)) {
                        $userDrives[$userName] = @()
                    }
                    
                    $networkKey.GetSubKeyNames() | % {
                        $driveLetter = $_
                        $driveKey = $networkKey.OpenSubKey($driveLetter)
                        
                        if ($driveKey) {
                            $driveInfo = New-Object psobject -Property @{
                                Computer = $computer
                                User = $userName
                                DriveLetter = $driveLetter
                                Map = $driveKey.GetValue('RemotePath')
                            }
                            
                            # Füge die Laufwerksinformation zum Array dieses Benutzers hinzu
                            $userDrives[$userName] += $driveInfo
                            
                            # Ressourcen freigeben
                            $driveKey.Close()
                        }
                    }
                }
                catch {
                    Write-Verbose "Fehler bei Verarbeitung von SID '$sid': $_"
                }
                
                # Ressourcen freigeben
                $networkKey.Close()
            }
        }
        
        # Ausgabe der nach Benutzern gruppierten Daten
        $userDrives.GetEnumerator() | % {
            $userName = $_.Key
            Write-Output "Netzlaufwerke für Benutzer: $userName"
            Write-Output "----------------------------------------"
            $_.Value | Format-Table -AutoSize
            Write-Output ""
        }
    }
    catch {
        Write-Error "Fehler beim Zugriff auf den Computer '$computer': $_"
    }
    finally {
        if ($reg) { $reg.Close() }
    }
}

function Get-MappedDrives {
<#
.SYNOPSIS
    Retrieves mapped network drives for all users on a remote computer.

.DESCRIPTION
    Connects to the remote registry of a specified computer to enumerate network drives
    mapped under all user SIDs found in the HKU hive.

.PARAMETER ComputerName
    The target computer name. Defaults to the local computer.

.EXAMPLE
    Get-MappedDrives -ComputerName SRV-01

.NOTES
    Requires the Remote Registry service to be running on the target machine.
    Dateiname:      Get-MappedDrives.ps1
    Autor:          Ismahil Ahmed
    Erstelldatum:   19.02.2022
    Version:        1.0
    

#>

    [CmdletBinding()]  
    param (
        [Parameter(Position = 0)]
        [string]$ComputerName = $env:COMPUTERNAME  
    )

    try {
        if (-not (Test-Connection -ComputerName $ComputerName -Count 1 -Quiet -ErrorAction Stop)) {
            Write-Warning "Computer '$ComputerName' is not reachable."
            return
        }
    }
    catch {
        Write-Warning "Connection error to '$ComputerName': $_"
        return
    }

    $userDrives = @{}

    try {
        $reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey('Users', $ComputerName)

        $reg.GetSubKeyNames() | Where-Object { $_ -match '\d{4,5}$' } | ForEach-Object {  
            $sid = $_
            $networkKey = $reg.OpenSubKey("$sid\Network")

            if ($networkKey) {
                try {
                    $userName = ([System.Security.Principal.SecurityIdentifier]$sid).Translate([System.Security.Principal.NTAccount]).Value

                    if (-not $userDrives.ContainsKey($userName)) {
                        $userDrives[$userName] = @()
                    }

                    $networkKey.GetSubKeyNames() | ForEach-Object {
                        $driveLetter = $_
                        $driveKey = $networkKey.OpenSubKey($driveLetter)

                        if ($driveKey) {
                            $driveInfo = [PSCustomObject]@{
                                Computer    = $ComputerName
                                User        = $userName
                                DriveLetter = $driveLetter
                                Map         = $driveKey.GetValue('RemotePath')
                            }

                            $userDrives[$userName] += $driveInfo
                            $driveKey.Close()
                        }
                    }
                }
                catch {
                    Write-Verbose "Error processing SID '$sid': $_"  
                }
                $networkKey.Close()
            }
        }

        $userDrives.GetEnumerator() | ForEach-Object {
            $userName = $_.Key
            Write-Output "Mapped drives for user: $userName"
            Write-Output "----------------------------------------"
            $_.Value | Format-Table -AutoSize
            Write-Output ""
        }
    }
    catch {
        Write-Error "Error accessing computer '$ComputerName': $_"
    }
    finally {
        if ($reg) { $reg.Close() }
    }
}

param (
    # Das Logverzeichnis – standardmäßig C:\Temp\log
    [string]$LogFilePath = "C:\Temp\log",
    # $Server ist verpflichtend (z.B. "Exampleserver.domain.de")
    [Parameter(Mandatory = $true)]
    [string]$Server,
    # Der Share wird aus dem Servernamen gebildet
	#[string]$ServerShare = '\\$Server\ofcscan',
    [string]$ServerShare = ('\\{0}\ofcscan' -f $Server),
    [string]$FileName = 'OFCSCAN.INI'
)

# Erstelle den ServerFilePath
$ServerFilePath = Join-Path $ServerShare "ofcscan.ini"

# Erstelle das Logverzeichnis, falls es nicht existiert
if (-not (Test-Path $LogFilePath)) {
    New-Item -Path $LogFilePath -ItemType Directory -Force | Out-Null
}

# Definiere den Pfad der Logdatei und das Archiv (als ZIP) im gleichen Verzeichnis
$LogFile = Join-Path $LogFilePath "log.txt"

# Das Archiv erhält einen Zeitstempel im Dateinamen; standardmäßig wird hier eine ZIP erstellt
$DefaultArchiveZipFilePattern = "log_archive_{0:yyyyMMdd_HHmmss}.zip"
$ArchiveZipFile = Join-Path $LogFilePath ([string]::Format($DefaultArchiveZipFilePattern, (Get-Date)))

function Write-Log {
    param (
        [string]$Message,
        [string]$LogFile
    )
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    "$timestamp - $Message" | Out-File -FilePath $LogFile -Append
}

function Install-TM {
    param (
        [string]$LogFile,
        [string]$LogFilePath,
        [string]$ArchiveZipFile,
        [string]$ServerFilePath,
        [string]$FileName
    )
    # Log-Rotation prüfen und durchführen
    if (Test-Path $LogFile) {
        $logSize = (Get-Item $LogFile).Length
        if ($logSize -gt 5MB) {
            $tempArchive = "$LogFile.tmp"
            Rename-Item -Path $LogFile -NewName $tempArchive -Force
            try {
                Compress-Archive -Path $tempArchive -DestinationPath $ArchiveZipFile -Force
                Remove-Item $tempArchive -Force
                Write-Log -Message "Archivierte Logdatei komprimiert zu: $ArchiveZipFile" -LogFile $LogFile
            }
            catch {
                Write-Log -Message "Fehler beim Komprimieren der archivierten Logdatei: $_" -LogFile $LogFile
            }
        }
    }
    Write-Log -Message "TM Skript läuft" -LogFile $LogFile

    # Lokale Pfade definieren (z.B. OfficeScan Client und Security Agent)
    $localPaths = @(
        Join-Path $env:"ProgramFiles(x86)" "Trend Micro\OfficeScan Client",
        Join-Path $env:"ProgramFiles(x86)" "Trend Micro\Security Agent"
    )

    # Lokale INI-Datei einlesen
    $lokalFile = $null
    foreach ($path in $localPaths) {
        $iniPath = Join-Path -Path $path -ChildPath $FileName
        if (Test-Path $iniPath) {
            try {
                $lokalFile = Get-Content -Path $iniPath -ErrorAction Stop
                if ($lokalFile) { break }
            }
            catch {
                Write-Log -Message "Fehler beim Lesen der lokalen INI-Datei in $iniPath: $_" -LogFile $LogFile
            }
        }
    }
    if (-not $lokalFile) {
        Write-Log -Message "Lokale INI-Datei nicht gefunden." -LogFile $LogFile
        return
    }

    # Lokale Version auslesen
    try {
        $localVersionString = ($lokalFile | Select-String -Pattern "PccNT_Version").Line.Split("=")[1].Trim()
        $localVersionParts = $localVersionString.Split(".")
        $localVersion = @{
            Version    = [int]$localVersionParts[0]
            SubVersion = [int]$localVersionParts[1]
            BuildNum   = [int]( ($lokalFile | Select-String -Pattern "PccNT_BuildNum").Line.Split("=")[1].Trim() )
        }
    }
    catch {
        Write-Log -Message "Fehler beim Auslesen der lokalen Version: $_" -LogFile $LogFile
        return
    }

    # Server INI-Datei einlesen
    if (-not (Test-Path $ServerFilePath)) {
        Write-Log -Message "Server INI-Datei nicht gefunden: $ServerFilePath" -LogFile $LogFile
        return
    }
    try {
        $serverFile = Get-Content -Path $ServerFilePath -ErrorAction Stop
    }
    catch {
        Write-Log -Message "Fehler beim Lesen der Server INI-Datei: $_" -LogFile $LogFile
        return
    }

    # Server Version auslesen
    try {
        $serverVersionString = ($serverFile | Select-String -Pattern "PccNT_Version").Line.Split("=")[1].Trim()
        $serverVersionParts = $serverVersionString.Split(".")
        $serverVersion = @{
            Version    = [int]$serverVersionParts[0]
            SubVersion = [int]$serverVersionParts[1]
            BuildNum   = [int]( ($serverFile | Select-String -Pattern "PccNT_BuildNum").Line.Split("=")[1].Trim() )
        }
    }
    catch {
        Write-Log -Message "Fehler beim Auslesen der Server Version: $_" -LogFile $LogFile
        return
    }

    # Installationsentscheidung treffen
    $clientPath = Join-Path $env:"ProgramFiles(x86)" "Trend Micro\OfficeScan Client"
    $startInstall = $false
    if (-not (Test-Path $clientPath)) {
        Write-Log -Message "OfficeScan Client nicht gefunden. Installation wird gestartet." -LogFile $LogFile
        $startInstall = $true
    }
    else {
        if ($localVersion.Version -lt $serverVersion.Version) {
            $startInstall = $true
        }
        elseif ($localVersion.Version -eq $serverVersion.Version -and $localVersion.SubVersion -lt $serverVersion.SubVersion) {
            $startInstall = $true
        }
        elseif ($localVersion.Version -eq $serverVersion.Version -and $localVersion.SubVersion -eq $serverVersion.SubVersion -and $localVersion.BuildNum -lt $serverVersion.BuildNum) {
            $startInstall = $true
        }
    }