Exchange nach dem Oktober-Patchday: Zähler überwachen statt Ausfall abwarten

cd C:\Temp
Unblock-File .\Install-ExRpcWatch.ps1
powershell -ExecutionPolicy Bypass -File .\Install-ExRpcWatch.ps1

& 'C:\Scripts\ExRpcWatch\ExRpcWatch.ps1' -Status

& 'C:\Scripts\ExRpcWatch\ExRpcWatch.ps1' -TestMail

powershell -ExecutionPolicy Bypass -File .\Install-ExRpcWatch.ps1 -Uninstall

<#
=====================================================================
 Install-ExRpcWatch.ps1
 Ueberwachung fuer Exchange-Server nach den Windows-Oktober-Updates 2026
 (Grenze der gespeicherten RPC-Endpoint-Mapper-Kontexte,
  Registry-Wert EpmapSavedContextCap)

 Das Skript
   - prueft die Voraussetzungen (Admin, Windows PowerShell 5.1, Exchange)
   - liest den lokalen Servernamen aus
   - fragt die Zieladresse fuer Warnmails ab
   - legt Verzeichnis, Konfiguration und Ueberwachungsskript an
   - richtet eine geplante Aufgabe ein (Standard: alle 15 Minuten)
   - bietet optional den Microsoft-Workaround (Registry-Wert) an
   - verschickt auf Wunsch eine Testmail

 Aufruf (PowerShell als Administrator, NICHT PowerShell 7):
   .\Install-ExRpcWatch.ps1
   .\Install-ExRpcWatch.ps1 -MailTo it@example.com -InstallPath D:\Tools\ExRpcWatch
   .\Install-ExRpcWatch.ps1 -Uninstall

 Wichtig:
   - Das Ueberwachungsskript liest den Prozessspeicher des Endpoint Mappers
     ausschliesslich lesend. Es veraendert nichts am System.
   - Zaehler und Grenze werden nur fuer bekannte Versionen von RpcEpMap.dll
     ausgelesen (Stand: 10.0.26100.33648, Windows Server 2025). Bei anderen
     Versionen laufen MAPI-Test, Warteschlangen- und Ereignispruefung weiter,
     die Spalten fuer Zaehler und Grenze bleiben leer.
   - Warnmails werden ueber das Pickup-Verzeichnis von Exchange zugestellt.
     Es ist kein Relay-Connector und kein Kennwort noetig.

 Stand: 19.10.2026 - codekunst systems GmbH
 Nutzung auf eigene Verantwortung. Vor dem produktiven Einsatz testen.
=====================================================================
#>

[CmdletBinding()]
param(
    [string]$MailTo,
    [string]$InstallPath = 'C:\Scripts\ExRpcWatch',
    [ValidateRange(5, 60)][int]$IntervalMinutes = 15,
    [ValidateRange(50, 99)][int]$ThresholdPercent = 90,
    [ValidateRange(1, 72)][int]$TicketLockHours = 12,
    [switch]$Uninstall
)

$TaskName    = 'ExRpcWatch'
$EventSource = 'ExRpcWatch'
$RegPath     = 'HKLM:\SOFTWARE\Microsoft\Rpc'
$RegName     = 'EpmapSavedContextCap'

function Write-Step([string]$Text) { Write-Host "==> $Text" -ForegroundColor Cyan }
function Write-Ok([string]$Text)   { Write-Host "    $Text" -ForegroundColor Green }
function Write-Warn([string]$Text) { Write-Host "    $Text" -ForegroundColor Yellow }

function Ask-YesNo([string]$Question, [bool]$Default) {
    $hint = if ($Default) { '[J/n]' } else { '[j/N]' }
    $a = Read-Host "$Question $hint"
    if ([string]::IsNullOrWhiteSpace($a)) { return $Default }
    return ($a.Trim().ToLower() -in @('j', 'ja', 'y', 'yes'))
}

# ---------------------------------------------------------------------
# Voraussetzungen
# ---------------------------------------------------------------------
Write-Step 'Pruefe Voraussetzungen'

$isAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole(
    [Security.Principal.WindowsBuiltInRole]::Administrator)
if (-not $isAdmin) { throw 'Bitte PowerShell als Administrator starten.' }

if ($PSVersionTable.PSVersion.Major -ne 5) {
    throw 'Bitte in Windows PowerShell 5.1 ausfuehren (powershell.exe), nicht in PowerShell 7 (pwsh.exe).'
}

if (-not $env:ExchangeInstallPath -or
    -not (Get-PSSnapin -Registered -Name 'Microsoft.Exchange.Management.PowerShell.SnapIn' -ErrorAction SilentlyContinue)) {
    throw 'Auf diesem Server ist keine Exchange-Verwaltungsumgebung installiert.'
}
Write-Ok 'Administrator, Windows PowerShell 5.1 und Exchange gefunden.'

# ---------------------------------------------------------------------
# Deinstallation
# ---------------------------------------------------------------------
if ($Uninstall) {
    Write-Step 'Entferne ExRpcWatch'
    if (Get-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue) {
        Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false
        Write-Ok "Geplante Aufgabe '$TaskName' entfernt."
    }
    if ([System.Diagnostics.EventLog]::SourceExists($EventSource)) {
        Remove-EventLog -Source $EventSource
        Write-Ok "Ereignisquelle '$EventSource' entfernt."
    }
    if ((Test-Path $InstallPath) -and (Ask-YesNo "Verzeichnis $InstallPath inklusive Protokollen loeschen?" $false)) {
        Remove-Item $InstallPath -Recurse -Force
        Write-Ok "Verzeichnis $InstallPath geloescht."
    }
    Write-Warn "Der Registry-Wert $RegName wurde NICHT veraendert."
    return
}

# ---------------------------------------------------------------------
# Server und Umgebung
# ---------------------------------------------------------------------
$computer = $env:COMPUTERNAME
$os       = Get-CimInstance Win32_OperatingSystem
$dll      = [System.Diagnostics.FileVersionInfo]::GetVersionInfo("$env:windir\System32\RpcEpMap.dll")
$dllVer   = '{0}.{1}.{2}.{3}' -f $dll.FileMajorPart, $dll.FileMinorPart, $dll.FileBuildPart, $dll.FilePrivatePart

Write-Step 'Server'
Write-Ok "Name           : $computer"
Write-Ok "Betriebssystem : $($os.Caption) (Build $($os.BuildNumber))"
Write-Ok "RpcEpMap.dll   : $dllVer"
if ($dllVer -ne '10.0.26100.33648') {
    Write-Warn 'Fuer diese DLL-Version sind keine Speicher-Offsets hinterlegt.'
    Write-Warn 'Zaehler und Grenze werden nicht ausgelesen, die uebrigen Pruefungen laufen.'
}

# ---------------------------------------------------------------------
# Zieladresse
# ---------------------------------------------------------------------
Write-Step 'Zieladresse fuer Warnmails'
$mailPattern = '^[^@\s]+@[^@\s]+\.[^@\s]+$'
while (-not ($MailTo -match $mailPattern)) {
    if ($MailTo) { Write-Warn "'$MailTo' ist keine gueltige Adresse." }
    $MailTo = Read-Host 'Zieladresse (z. B. ticket@ihre-firma.de)'
}
Write-Ok "Warnmails gehen an: $MailTo"

# ---------------------------------------------------------------------
# Verzeichnis und Konfiguration
# ---------------------------------------------------------------------
Write-Step "Lege $InstallPath an"
New-Item -ItemType Directory -Path $InstallPath -Force | Out-Null

[pscustomobject]@{
    Server           = $computer
    MailTo           = $MailTo
    ThresholdPercent = $ThresholdPercent
    TicketLockHours  = $TicketLockHours
    IntervalMinutes  = $IntervalMinutes
    Installed        = (Get-Date -Format s)
} | ConvertTo-Json | Set-Content -Path (Join-Path $InstallPath 'config.json') -Encoding ASCII
Write-Ok 'config.json geschrieben.'

# ---------------------------------------------------------------------
# Ueberwachungsskript
# ---------------------------------------------------------------------
$watch = @'
# =====================================================================
# ExRpcWatch.ps1 - angelegt von Install-ExRpcWatch.ps1
# Einstellungen in config.json im selben Verzeichnis.
#
#   .\ExRpcWatch.ps1            normaler Lauf (geplante Aufgabe)
#   .\ExRpcWatch.ps1 -Status    aktuelle Werte anzeigen, nichts schreiben
#   .\ExRpcWatch.ps1 -TestMail  Testmail an die Zieladresse senden
#
# Liest den Speicher des Endpoint Mappers ausschliesslich lesend.
# =====================================================================
param([switch]$Status, [switch]$TestMail)

$base  = Split-Path -Parent $MyInvocation.MyCommand.Path
$cfg   = Get-Content (Join-Path $base 'config.json') -Raw | ConvertFrom-Json
$csv   = Join-Path $base 'ExRpcWatch.csv'
$tlog  = Join-Path $base 'ExRpcWatch.log'

# Bekannte Speicher-Offsets je DLL-Version (Build.Revision)
$offsets = @{
    '26100.33648' = @{ Cap = 0x1C5EC; Cnt = 0x1CD50 }
}

# Protokolle begrenzen
foreach ($f in @($tlog, $csv)) {
    if ((Test-Path $f) -and (Get-Item $f).Length -gt 5MB) { Move-Item $f "$f.old" -Force }
}

if (-not $Status) { Start-Transcript -Path $tlog -Append | Out-Null }

try {
    Add-PSSnapin Microsoft.Exchange.Management.PowerShell.SnapIn -ErrorAction Stop

    if (-not ('EpMem' -as [type])) {
        Add-Type @"
using System;
using System.Runtime.InteropServices;
public static class EpMem {
    [DllImport("kernel32.dll", SetLastError=true)]
    public static extern IntPtr OpenProcess(uint access, bool inherit, int procId);
    [DllImport("kernel32.dll", SetLastError=true)]
    public static extern bool ReadProcessMemory(IntPtr h, IntPtr addr, byte[] buf, int size, out IntPtr read);
    [DllImport("kernel32.dll")]
    public static extern bool CloseHandle(IntPtr h);
}
"@
    }

    # --- Grunddaten ---
    $svc       = Get-CimInstance Win32_Service -Filter "Name='RpcEptMapper'"
    $os        = Get-CimInstance Win32_OperatingSystem
    $uptimeMin = ((Get-Date) - $os.LastBootUpTime).TotalMinutes
    $regVal    = (Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Rpc' -Name EpmapSavedContextCap -ErrorAction SilentlyContinue).EpmapSavedContextCap

    # --- MAPI-Test (sprachunabhaengig) ---
    $mapi = Test-MAPIConnectivity -Server $env:COMPUTERNAME -ErrorAction SilentlyContinue
    $mapiFail = $null
    if ($mapi) {
        $mapiFail = @($mapi | Where-Object {
            -not [string]::IsNullOrWhiteSpace("$($_.Error)") -or
            @('Success', 'Erfolgreich') -notcontains "$($_.Result)"
        }).Count
    }

    # --- Warteschlangen ---
    $queue = (Get-Queue -Server $env:COMPUTERNAME -ErrorAction SilentlyContinue | Measure-Object MessageCount -Sum).Sum

    # --- Ereignis 1006 (nur Exchange + MdbOffline, nicht in den ersten 30 Min.) ---
    $ev1006 = 0
    if ($uptimeMin -gt 30) {
        $ev1006 = @(Get-WinEvent -FilterHashtable @{ LogName = 'Application'; Id = 1006; StartTime = (Get-Date).AddMinutes(-15) } -ErrorAction SilentlyContinue |
                    Where-Object { $_.ProviderName -like 'MSExchange*' -and $_.Message -like '*MdbOffline*' }).Count
    }

    # --- Grenze und Zaehler aus dem Speicher (nur bekannte DLL-Versionen) ---
    $cap = $null; $cnt = $null; $grund = $null
    try {
        $v   = [System.Diagnostics.FileVersionInfo]::GetVersionInfo("$env:windir\System32\RpcEpMap.dll")
        $ver = "$($v.FileBuildPart).$($v.FilePrivatePart)"
        if (-not $offsets.ContainsKey($ver)) {
            if ($v.FileBuildPart -eq 26100 -and $v.FilePrivatePart -lt 33648) {
                $grund = "RpcEpMap.dll $ver ist aelter als das Oktober-Update 2026 - Update nicht installiert oder Neustart ausstehend. Die Grenze von 512 existiert hier noch nicht."
            } else {
                $grund = "Fuer RpcEpMap.dll $ver sind keine Speicher-Offsets hinterlegt (bisher nur Windows Server 2025, 10.0.26100.33648). MAPI-Test, Warteschlangen und Ereignisse werden trotzdem geprueft."
            }
        }
        else {
            $mod = (Get-Process -Id $svc.ProcessId).Modules | Where-Object { $_.ModuleName -eq 'RpcEpMap.dll' }
            $h   = [EpMem]::OpenProcess(0x0410, $false, $svc.ProcessId)
            if ($h -ne [IntPtr]::Zero -and $mod) {
                $rd = {
                    param($off)
                    $b = New-Object byte[] 4; $r = [IntPtr]::Zero
                    [void][EpMem]::ReadProcessMemory($h, [IntPtr]($mod.BaseAddress.ToInt64() + $off), $b, 4, [ref]$r)
                    [BitConverter]::ToUInt32($b, 0)
                }
                $c = & $rd $offsets[$ver].Cap
                $n = & $rd $offsets[$ver].Cnt
                [void][EpMem]::CloseHandle($h)
                # Plausibilitaet: Grenze muss 512 (Standard) oder der Registry-Wert sein
                if ($c -eq 512 -or ($regVal -and $c -eq [uint32]$regVal)) { $cap = $c; $cnt = $n }
                else { $grund = "Unplausible Grenze im Speicher ($c) - Werte verworfen." }
            }
        }
    } catch { $grund = "Speicher nicht lesbar: $($_.Exception.Message)" }
    if ($grund -and -not $Status) { Write-Output "Zaehler/Grenze leer: $grund" }

    $regAusstehend = ($regVal -and $cap -eq 512 -and [uint32]$regVal -ne 512)

    $zeile = [pscustomobject]@{
        Zeit         = Get-Date -Format s
        Server       = $env:COMPUTERNAME
        UptimeStd    = [math]::Round($uptimeMin / 60, 1)
        EpmapGrenze  = $cap
        EpmapZaehler = $cnt
        RegWert      = $regVal
        MapiFehler   = $mapiFail
        QueueSumme   = $queue
        Ereignis1006 = $ev1006
    }

    if ($Status) {
        $zeile | Format-List
        if ($grund) { Write-Output "Hinweis zu Zaehler/Grenze: $grund" }
        if ($regAusstehend) { Write-Output 'Hinweis: Registry-Wert gesetzt, aber noch nicht aktiv - Neustart erforderlich.' }
        return
    }

    $zeile | Export-Csv $csv -Append -NoTypeInformation -Delimiter ';' -Encoding UTF8

    # --- Bewertung ---
    $schwelle = [double]$cfg.ThresholdPercent / 100
    $kritisch = ($cnt -ne $null -and $cap -gt 0 -and $cnt -gt ($schwelle * $cap))
    $ausfall  = (($mapiFail -gt 0) -or ($ev1006 -gt 0))

    if (-not [System.Diagnostics.EventLog]::SourceExists('ExRpcWatch')) {
        New-EventLog -LogName Application -Source 'ExRpcWatch'
    }
    $info = "MAPI-Fehler: $mapiFail, Ereignis 1006 (MdbOffline): $ev1006, Queue: $queue, " +
            "Uptime: $($zeile.UptimeStd) h, Zaehler: $cnt / Grenze: $cap, Registry: $regVal"

    if ($kritisch -or $ausfall) {
        Write-EventLog -LogName Application -Source 'ExRpcWatch' -EventId 9001 -EntryType Error -Message "ExRpcWatch: $info"
    } elseif ($regAusstehend) {
        Write-EventLog -LogName Application -Source 'ExRpcWatch' -EventId 9002 -EntryType Warning `
            -Message "ExRpcWatch: Registry-Wert $regVal gesetzt, im Speicher gilt noch 512. Neustart erforderlich. $info"
    }

    # --- Mail ueber das Pickup-Verzeichnis ---
    function Send-ExTicket([string]$Art, [string]$Betreff, [string[]]$Text, [switch]$Force) {
        $marker = Join-Path $base "ticket_$Art.marker"
        if (-not $Force -and (Test-Path $marker)) {
            $z = (Get-Item $marker).LastWriteTime
            if ($z -gt $os.LastBootUpTime -and $z -gt (Get-Date).AddHours(-[int]$cfg.TicketLockHours)) { return }
        }
        try {
            $pickup = "$((Get-TransportService -Identity $env:COMPUTERNAME).PickupDirectoryPath)"
            if (-not $pickup) { $pickup = Join-Path $env:ExchangeInstallPath 'TransportRoles\Pickup' }
            $domain = "$((Get-AcceptedDomain | Where-Object { $_.Default }).DomainName)"
            $mail = @(
                "From: ExRpcWatch <exrpcwatch@$domain>",
                "To: $($cfg.MailTo)",
                "Subject: $Betreff",
                "Date: $((Get-Date).ToUniversalTime().ToString('r'))",
                'MIME-Version: 1.0',
                'Content-Type: text/plain; charset=us-ascii',
                'X-ExRpcWatch: 1',
                ''
            ) + $Text
            $datei = Join-Path $pickup ("ExRpcWatch_{0}_{1}.eml" -f $Art, (Get-Date -Format 'yyyyMMdd_HHmmss'))
            [System.IO.File]::WriteAllText($datei, ($mail -join "`r`n"), [System.Text.Encoding]::ASCII)
            if (-not $Force) { Set-Content -Path $marker -Value (Get-Date -Format s) }
            Write-Output "Mail abgelegt: $datei"
        } catch { Write-Output "Mail fehlgeschlagen: $($_.Exception.Message)" }
    }

    $details = @(
        "Server        : $env:COMPUTERNAME",
        "Zeit          : $(Get-Date -Format 'dd.MM.yyyy HH:mm:ss')",
        "Laufzeit      : $($zeile.UptimeStd) Stunden seit $($os.LastBootUpTime.ToString('dd.MM.yyyy HH:mm'))",
        "Epmap-Zaehler : $cnt",
        "Epmap-Grenze  : $cap",
        "Registry-Wert : $regVal",
        "MAPI-Fehler   : $mapiFail",
        "Queue         : $queue",
        "Ereignis 1006 : $ev1006",
        '',
        'Automatisch erzeugt von ExRpcWatch.ps1'
    )

    if ($TestMail) {
        Send-ExTicket -Art 'test' -Force -Betreff "[ExRpcWatch] TEST $env:COMPUTERNAME - Testmail" `
            -Text (@('Dies ist eine Testmail von ExRpcWatch.', '') + $details)
    }
    if ($kritisch) {
        Send-ExTicket -Art 'kritisch' -Betreff "[ExRpcWatch] $env:COMPUTERNAME - RPC-Zaehler kritisch ($cnt von $cap)" `
            -Text (@('Der Zaehler der gespeicherten RPC-Endpoint-Mapper-Kontexte hat die Warnschwelle erreicht.',
                     'Bei Erreichen der Grenze faellt Exchange aus (MapiExceptionMdbOffline).',
                     'Massnahme: kontrollierten Neustart einplanen, EpmapSavedContextCap pruefen.', '') + $details)
    }
    if ($ausfall) {
        Send-ExTicket -Art 'ausfall' -Betreff "[ExRpcWatch] $env:COMPUTERNAME - Exchange-Stoerung (MdbOffline/MAPI)" `
            -Text (@('Exchange meldet MAPI-Fehler oder MdbOffline-Ereignisse.',
                     'Hinweis: Bei einem Ausfall kann diese Mail verzoegert zugestellt werden.', '') + $details)
    }
}
catch { Write-Output "FEHLER: $($_.Exception.Message)" }
finally { if (-not $Status) { Stop-Transcript | Out-Null } }
'@

$watchPath = Join-Path $InstallPath 'ExRpcWatch.ps1'
Set-Content -Path $watchPath -Value $watch -Encoding ASCII
Write-Ok "Ueberwachungsskript angelegt: $watchPath"

# ---------------------------------------------------------------------
# Ereignisquelle
# ---------------------------------------------------------------------
if (-not [System.Diagnostics.EventLog]::SourceExists($EventSource)) {
    New-EventLog -LogName Application -Source $EventSource
    Write-Ok "Ereignisquelle '$EventSource' registriert."
}

# ---------------------------------------------------------------------
# Geplante Aufgabe
# ---------------------------------------------------------------------
Write-Step "Richte geplante Aufgabe '$TaskName' ein (alle $IntervalMinutes Minuten)"
$psExe     = "$env:windir\System32\WindowsPowerShell\v1.0\powershell.exe"
$action    = New-ScheduledTaskAction -Execute $psExe -Argument "-NoProfile -ExecutionPolicy Bypass -File `"$watchPath`""
$trigger   = New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(1) -RepetitionInterval (New-TimeSpan -Minutes $IntervalMinutes)
$settings  = New-ScheduledTaskSettingsSet -ExecutionTimeLimit (New-TimeSpan -Minutes 5) -MultipleInstances IgnoreNew -StartWhenAvailable
$principal = New-ScheduledTaskPrincipal -UserId 'SYSTEM' -LogonType ServiceAccount -RunLevel Highest
Register-ScheduledTask -TaskName $TaskName -Action $action -Trigger $trigger -Settings $settings -Principal $principal -Force | Out-Null
Write-Ok 'Geplante Aufgabe eingerichtet (Konto SYSTEM, Zeitlimit 5 Minuten).'

# ---------------------------------------------------------------------
# Registry-Workaround (optional)
# ---------------------------------------------------------------------
Write-Step 'Microsoft-Workaround EpmapSavedContextCap'
$regVal = (Get-ItemProperty $RegPath -Name $RegName -ErrorAction SilentlyContinue).$RegName
if ($regVal) {
    Write-Ok "Bereits gesetzt: $regVal"
} else {
    Write-Warn 'Nicht gesetzt. Microsoft empfiehlt den Wert 65536 (wirksam erst nach einem Neustart).'
    if (Ask-YesNo 'Jetzt auf 65536 setzen?' $false) {
        New-ItemProperty -Path $RegPath -Name $RegName -PropertyType DWord -Value 65536 -Force | Out-Null
        Write-Ok 'Gesetzt. Bitte den Server in einem passenden Fenster neu starten.'
    }
}

# ---------------------------------------------------------------------
# Erster Lauf und Testmail
# ---------------------------------------------------------------------
Write-Step 'Aktueller Status'
& $watchPath -Status

if (Ask-YesNo "Testmail an $MailTo senden?" $true) {
    & $watchPath -TestMail | Out-Null
    Write-Ok 'Testmail im Pickup-Verzeichnis abgelegt. Bitte Eingang pruefen.'
}

Write-Step 'Fertig'
Write-Ok "Protokolle   : $InstallPath\ExRpcWatch.csv und ExRpcWatch.log"
Write-Ok "Status       : & '$watchPath' -Status"
Write-Ok "Ereignisse   : Anwendungsprotokoll, Quelle $EventSource, ID 9001 (Fehler) und 9002 (Neustart ausstehend)"
Write-Ok "Entfernen    : .\Install-ExRpcWatch.ps1 -Uninstall -InstallPath '$InstallPath'"